Changeset 927


Ignore:
Timestamp:
Mar 6, 2008 4:01:20 PM (16 years ago)
Author:
gah
Message:

collect limits for axes

Location:
trunk/vizservers/nanovis
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/vizservers/nanovis/Command.cpp

    r923 r927  
    1 
     1 
    22/*
    33 * ----------------------------------------------------------------------
    … …  
    4040 */
    4141
    42 #define ISO_TEST                1
    43 #define PLANE_CMD               0
    44 #define __TEST_CODE__           0
    45 // FOR testing new functions
    46 #define _LOCAL_ZINC_TEST_       0
    47 
    4842#include <tcl.h>
    4943#include "Trace.h"
    … …  
    7973#include <NvLIC.h>
    8074
     75#define ISO_TEST                1
     76#define PLANE_CMD               0
     77#define __TEST_CODE__           0
     78// FOR testing new functions
     79#define _LOCAL_ZINC_TEST_       0
     80
    8181#if _LOCAL_ZINC_TEST_
    8282#include "Test.h"
    … …  
    9696extern Rappture::Outcome load_volume_stream(int index, std::iostream& fin);
    9797extern Rappture::Outcome load_volume_stream_odx(int index, const char *buf,
    98         int nBytes);
     98                                                int nBytes);
    9999extern Rappture::Outcome load_volume_stream2(int index, std::iostream& fin);
    100100extern void load_volume(int index, int width, int height, int depth,
    101         int n_component, float* data, double vmin, double vmax,
    102         double nzero_min);
     101                        int n_component, float* data, double vmin, double vmax,
     102                        double nzero_min);
    103103extern void load_vector_stream(int index, std::istream& fin);
    104104
    … …  
    151151static Tcl_ObjCmdProc VolumeCmd;
    152152
     153static bool
     154GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, bool *boolPtr)
     155{
     156    int value;
     157
     158    if (Tcl_GetBooleanFromObj(interp, objPtr, &value) != TCL_OK) {
     159        return TCL_ERROR;
     160    }
     161    *boolPtr = (bool)value;
     162    return TCL_OK;
     163}
     164
    153165static int
    154166GetFloatFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, float *valuePtr)
    … …  
    165177static int
    166178GetCullMode(Tcl_Interp *interp, Tcl_Obj *objPtr,
    167         graphics::RenderContext::CullMode *modePtr)
     179            graphics::RenderContext::CullMode *modePtr)
    168180{
    169181    char *string = Tcl_GetString(objPtr);
    … …  
    176188    } else {
    177189        Tcl_AppendResult(interp, "invalid cull mode \"", string,
    178                 "\": should be front, back, or none\"", (char *)NULL);
     190                        "\": should be front, back, or none\"", (char *)NULL);
    179191        return TCL_ERROR;
    180192    }
    … …  
    210222    } else {
    211223        Tcl_AppendResult(interp, "invalid polygon mode \"", string,
    212         "\": should be wireframe or fill\"", (char *)NULL);
     224                        "\": should be wireframe or fill\"", (char *)NULL);
    213225        return TCL_ERROR;
    214226    }
    … …  
    279291    if (objc != 7) {
    280292        Tcl_AppendResult(interp,
    281         "wrong # of values: should be xMin yMin xMax yMax xNum yNum heights",
    282                 (char *)NULL);
     293                        "wrong # of values: should be xMin yMin xMax yMax xNum yNum heights",
     294                        (char *)NULL);
    283295        return NULL;
    284296    }
    … …  
    309321    if (heights == NULL) {
    310322        Tcl_AppendResult(interp, "can't allocate array of heights",
    311                 (char *)NULL);
     323                        (char *)NULL);
    312324        return NULL;
    313325    }
    … …  
    353365        (NanoVis::heightMap[mapIndex] == NULL)) {
    354366        Tcl_AppendResult(interp, "invalid heightmap index \"",
    355                 Tcl_GetString(objPtr), "\"", (char *)NULL);
     367                        Tcl_GetString(objPtr), "\"", (char *)NULL);
    356368        return TCL_ERROR;
    357369    }
    … …  
    382394    if (index < 0) {
    383395        Tcl_AppendResult(interp, "can't have negative index \"",
    384                 Tcl_GetString(objPtr), "\"", (char*)NULL);
     396                        Tcl_GetString(objPtr), "\"", (char*)NULL);
    385397        return TCL_ERROR;
    386398    }
    … …  
    418430    if (vol == NULL) {
    419431        Tcl_AppendResult(interp, "no volume defined for index \"",
    420                 Tcl_GetString(objPtr), "\"", (char*)NULL);
     432                        Tcl_GetString(objPtr), "\"", (char*)NULL);
    421433        return TCL_ERROR;
    422434    }
    … …  
    440452static int
    441453GetVolumeIndices(Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv,
    442     vector<unsigned int>* vectorPtr)
     454                vector<unsigned int>* vectorPtr)
    443455{
    444456    if (objc == 0) {
    … …  
    465477static int
    466478GetIndices(Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv,
    467     vector<unsigned int>* vectorPtr)
     479           vector<unsigned int>* vectorPtr)
    468480{
    469481    for (int n = 0; n < objc; n++) {
    … …  
    475487        if (index < 0) {
    476488            Tcl_AppendResult(interp, "can't have negative index \"",
    477                 Tcl_GetString(objv[n]), "\"", (char *)NULL);
     489                             Tcl_GetString(objv[n]), "\"", (char *)NULL);
    478490            return TCL_ERROR;
    479491        }
    … …  
    499511static int
    500512GetVolumes(Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv,
    501     vector<Volume *>* vectorPtr)
     513           vector<Volume *>* vectorPtr)
    502514{
    503515    if (objc == 0) {
    … …  
    508520        }
    509521    } else {
    510         for (int n = 0; n < objc; n++) {
     522        for (unsigned int n = 0; n < objc; n++) {
    511523            Volume *volPtr;
    512524
    … …  
    553565    }
    554566    Tcl_AppendResult(interp, "bad axis \"", string,
    555         "\": should be x, y, or z", (char*)NULL);
     567                     "\": should be x, y, or z", (char*)NULL);
    556568    return TCL_ERROR;
    557569}
    … …  
    617629    if (objc < 3) {
    618630        Tcl_AppendResult(interp, "missing color values\": ",
    619                 "should list of R G B values 0.0 - 1.0", (char*)NULL);
     631                        "should list of R G B values 0.0 - 1.0", (char*)NULL);
    620632        return TCL_ERROR;
    621633    }
    … …  
    654666        if (ferror(stdin)) {
    655667            Tcl_AppendResult(interp, "while reading data stream: ",
    656                 Tcl_PosixError(interp), (char*)NULL);
     668                             Tcl_PosixError(interp), (char*)NULL);
    657669            return TCL_ERROR;
    658670        }
    659671        if (feof(stdin)) {
    660672            Tcl_AppendResult(interp, "premature EOF while reading data stream",
    661                 (char*)NULL);
     673                             (char*)NULL);
    662674            return TCL_ERROR;
    663675        }
    … …  
    717729
    718730static Rappture::CmdSpec cameraOps[] =
    719 {
    720     {"aim",     2, CameraAimOp,      5, 5, "x y z",},
    721     {"angle",   2, CameraAngleOp,    5, 5, "xAngle yAngle zAngle",},
    722     {"zoom",    1, CameraZoomOp,     3, 3, "factor",},
    723 };
     731    {
     732        {"aim",     2, CameraAimOp,      5, 5, "x y z",},
     733        {"angle",   2, CameraAngleOp,    5, 5, "xAngle yAngle zAngle",},
     734        {"zoom",    1, CameraZoomOp,     3, 3, "factor",},
     735    };
    724736static int nCameraOps = NumCmdSpecs(cameraOps);
    725737
    … …  
    743755
    744756    proc = Rappture::GetOpFromObj(interp, nCameraOps, cameraOps,
    745                 Rappture::CMDSPEC_ARG1, objc, objv, 0);
     757                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
    746758    if (proc == NULL) {
    747759        return TCL_ERROR;
    … …  
    763775    // TBD
    764776    /*
    765     Volume* vol = NanoVis::volume[0];
    766     TransferFunction* tf;
    767     tf = NanoVis::vol_renderer->get_volume_shading(vol);
    768     if (tf != NULL)
    769     {
    770         float data[512];
    771 
    772         for (int i=0; i < 256; i++) {
    773             data[i] = data[i+256] = (float)(i/255.0);
    774         }
    775         Texture2D* plane = new Texture2D(256, 2, GL_FLOAT, GL_LINEAR, 1, data);
    776         NanoVis::color_table_renderer->render(1024, 1024, plane, tf, vol->range_min(),
    777                 vol->range_max());
    778         delete plane;
     777      Volume* vol = NanoVis::volume[0];
     778      TransferFunction* tf;
     779      tf = NanoVis::vol_renderer->get_volume_shading(vol);
     780      if (tf != NULL)
     781      {
     782      float data[512];
     783
     784      for (int i=0; i < 256; i++) {
     785      data[i] = data[i+256] = (float)(i/255.0);
     786      }
     787      Texture2D* plane = new Texture2D(256, 2, GL_FLOAT, GL_LINEAR, 1, data);
     788      NanoVis::color_table_renderer->render(1024, 1024, plane, tf, vol->range_min(),
     789      vol->range_max());
     790      delete plane;
    779791   
    780     }
     792      }
    781793    */
    782794#endif
    … …  
    821833                Tcl_Obj *CONST *objv)
    822834{
    823     int state;
    824     if (Tcl_GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     835    bool state;
     836    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
    825837        return TCL_ERROR;
    826838    }
    … …  
    850862
    851863static Rappture::CmdSpec cutplaneOps[] =
    852 {
    853     {"position", 1, CutplanePositionOp, 4, 0, "bool axis ?indices?",},
    854     {"state",    1, CutplaneStateOp,    4, 0, "relval axis ?indices?",},
    855 };
     864    {
     865        {"position", 1, CutplanePositionOp, 4, 0, "bool axis ?indices?",},
     866        {"state",    1, CutplaneStateOp,    4, 0, "relval axis ?indices?",},
     867    };
    856868static int nCutplaneOps = NumCmdSpecs(cutplaneOps);
    857869
    … …  
    877889
    878890    proc = Rappture::GetOpFromObj(interp, nCutplaneOps, cutplaneOps,
    879                 Rappture::CMDSPEC_ARG1, objc, objv, 0);
     891                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
    880892    if (proc == NULL) {
    881893        return TCL_ERROR;
    … …  
    900912    if (objc != 4) {
    901913        Tcl_AppendResult(interp, "wrong # args: should be \"",
    902                 Tcl_GetString(objv[0]), " volIndex width height\"", (char*)NULL);
     914                        Tcl_GetString(objv[0]), " volIndex width height\"", (char*)NULL);
    903915        return TCL_ERROR;
    904916    }
    … …  
    912924    if (tf == NULL) {
    913925        Tcl_AppendResult(interp, "no transfer function defined for volume \"",
    914                 Tcl_GetString(objv[1]), "\"", (char*)NULL);
     926                        Tcl_GetString(objv[1]), "\"", (char*)NULL);
    915927        return TCL_ERROR;
    916928    }
    … …  
    945957    if (objc != 3) {
    946958        Tcl_AppendResult(interp, "wrong # args: should be \"",
    947                 Tcl_GetString(objv[0]), " width height\"", (char*)NULL);
     959                        Tcl_GetString(objv[0]), " width height\"", (char*)NULL);
    948960        return TCL_ERROR;
    949961    }
    … …  
    973985    if (objc < 2) {
    974986        Tcl_AppendResult(interp, "wrong # args: should be \"",
    975                 Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
     987                        Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
    976988        return TCL_ERROR;
    977989    }
    … …  
    982994        if (objc != 5) {
    983995            Tcl_AppendResult(interp, "wrong # args: should be \"",
    984                 Tcl_GetString(objv[0]), " define name colormap alphamap\"",
    985                 (char*)NULL);
     996                             Tcl_GetString(objv[0]), " define name colormap alphamap\"",
     997                             (char*)NULL);
    986998            return TCL_ERROR;
    987999        }
    … …  
    9991011        if ((cmapc % 4) != 0) {
    10001012            Tcl_AppendResult(interp, "bad colormap in transfunc: should be ",
    1001                 "{ v r g b ... }", (char*)NULL);
     1013                             "{ v r g b ... }", (char*)NULL);
    10021014            return TCL_ERROR;
    10031015        }
    … …  
    10071019        if ((wmapc % 2) != 0) {
    10081020            Tcl_AppendResult(interp, "wrong # elements in alphamap: should be ",
    1009                         " { v w ... }", (char*)NULL);
     1021                             " { v w ... }", (char*)NULL);
    10101022            return TCL_ERROR;
    10111023        }
    … …  
    10201032                if ((vals[j] < 0.0) || (vals[j] > 1.0)) {
    10211033                    Tcl_AppendResult(interp, "bad value \"", cmapv[i+j],
    1022                         "\": should be in the range 0-1", (char*)NULL);
     1034                                     "\": should be in the range 0-1", (char*)NULL);
    10231035                    return TCL_ERROR;
    10241036                }
    … …  
    10381050                if ((vals[j] < 0.0) || (vals[j] > 1.0)) {
    10391051                    Tcl_AppendResult(interp, "bad value \"", wmapv[i+j],
    1040                         "\": should be in the range 0-1", (char*)NULL);
     1052                                     "\": should be in the range 0-1", (char*)NULL);
    10411053                    return TCL_ERROR;
    10421054                }
    … …  
    10651077    } else {
    10661078        Tcl_AppendResult(interp, "bad option \"", string,
    1067                 "\": should be define", (char*)NULL);
     1079                        "\": should be define", (char*)NULL);
    10681080        return TCL_ERROR;
    10691081    }
    … …  
    10851097    if (objc != 2) {
    10861098        Tcl_AppendResult(interp, "wrong # args: should be \"",
    1087                 Tcl_GetString(objv[0]), " x|y|z|-x|-y|-z\"", (char*)NULL);
     1099                        Tcl_GetString(objv[0]), " x|y|z|-x|-y|-z\"", (char*)NULL);
    10881100        return TCL_ERROR;
    10891101    }
    … …  
    10981110}
    10991111
    1100 #ifdef notdef
     1112#ifndef notdef
     1113
     1114static int
     1115VolumeAnimationCaptureOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1116                         Tcl_Obj *CONST *objv)
     1117{
     1118    int total;
     1119    if (Tcl_GetIntFromObj(interp, objv[3], &total) != TCL_OK) {
     1120        return TCL_ERROR;
     1121    }
     1122    VolumeInterpolator* interpolator;
     1123    interpolator = NanoVis::vol_renderer->getVolumeInterpolator();
     1124    interpolator->start();
     1125    if (interpolator->is_started()) {
     1126        char *fileName = (objc < 5) ? NULL : Tcl_GetString(objv[4]);
     1127        for (int frame_num = 0; frame_num < total; ++frame_num) {
     1128            float fraction;
     1129           
     1130            fraction = ((float)frame_num) / (total - 1);
     1131            Trace("fraction : %f\n", fraction);
     1132            //interpolator->update(((float)frame_num) / (total - 1));
     1133            interpolator->update(fraction);
     1134           
     1135            NanoVis::offscreen_buffer_capture();  //enable offscreen render
     1136           
     1137            NanoVis::display();
     1138            NanoVis::read_screen();
     1139           
     1140            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1141           
     1142            NanoVis::bmp_write_to_file(frame_num, fileName);
     1143        }
     1144    }
     1145    return TCL_OK;
     1146}
     1147
     1148static int
     1149VolumeAnimationClearOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1150                       Tcl_Obj *CONST *objv)
     1151{
     1152    NanoVis::vol_renderer->clearAnimatedVolumeInfo();
     1153    return TCL_OK;
     1154}
     1155
     1156static int
     1157VolumeAnimationStartOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1158                       Tcl_Obj *CONST *objv)
     1159{
     1160    NanoVis::vol_renderer->startVolumeAnimation();
     1161    return TCL_OK;
     1162}
     1163
     1164static int
     1165VolumeAnimationStopOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1166                      Tcl_Obj *CONST *objv)
     1167{
     1168    NanoVis::vol_renderer->stopVolumeAnimation();
     1169    return TCL_OK;
     1170}
     1171
     1172static int
     1173VolumeAnimationVolumesOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1174                         Tcl_Obj *CONST *objv)
     1175{
     1176    vector<unsigned int> ivol;
     1177    if (GetVolumeIndices(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
     1178        return TCL_ERROR;
     1179    }
     1180    Trace("parsing volume index\n");
     1181    vector<unsigned int>::iterator iter;
     1182    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1183        Trace("index: %d\n", *iter);
     1184        NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volume[*iter], *iter);
     1185    }
     1186    return TCL_OK;
     1187}
     1188
    11011189static Rappture::CmdSpec volumeAnimationOps[] =
    1102 {
    1103     {"capture",   2, VolumeAnimationCaptureOp,  4, 0, "value ?indices?",},
    1104     {"clear",     2, VolumeAnimationClearOp,    4, 0, "value ?indices?",},
    1105     {"start",     3, VolumeAnimationStartOp,    4, 0, "value ?indices?",},
    1106     {"stop",      3, VolumeAnimationStopOp,     4, 0, "bool ?indices?",},
    1107     {"volumes",   1, VolumeAnimationVolumesOp,  4, 0, "funcName ?indices?",},
    1108 };
     1190    {
     1191        {"capture",   2, VolumeAnimationCaptureOp,  4, 5, "numframes ?filename?",},
     1192        {"clear",     2, VolumeAnimationClearOp,    3, 3, "",},
     1193        {"start",     3, VolumeAnimationStartOp,    3, 3, "",},
     1194        {"stop",      3, VolumeAnimationStopOp,     3, 3, "",},
     1195        {"volumes",   1, VolumeAnimationVolumesOp,  3, 0, "?indices?",},
     1196    };
     1197
    11091198static int nVolumeAnimationOps = NumCmdSpecs(volumeAnimationOps);
     1199
     1200static int
     1201VolumeAnimationOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1202                  Tcl_Obj *CONST *objv)
     1203{
     1204    Tcl_ObjCmdProc *proc;
     1205
     1206    proc = Rappture::GetOpFromObj(interp, nVolumeAnimationOps, volumeAnimationOps,
     1207                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
     1208    if (proc == NULL) {
     1209        return TCL_ERROR;
     1210    }
     1211    return (*proc) (cdata, interp, objc, objv);
     1212}
     1213
    11101214
    11111215static int
    … …  
    12601364                  Tcl_Obj *CONST *objv)
    12611365{
    1262     int state;
    1263     if (Tcl_GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
     1366    bool state;
     1367    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
    12641368        return TCL_ERROR;
    12651369    }
    … …  
    12831387
    12841388static Rappture::CmdSpec volumeDataOps[] =
    1285 {
    1286     {"follows",   1, VolumeDataFollowsOp, 4, 4, "size",},
    1287     {"state",     1, VolumeDataStateOp,   4, 0, "bool ?indices?",},
    1288 };
     1389    {
     1390        {"follows",   1, VolumeDataFollowsOp, 4, 4, "size",},
     1391        {"state",     1, VolumeDataStateOp,   4, 0, "bool ?indices?",},
     1392    };
    12891393static int nVolumeDataOps = NumCmdSpecs(volumeDataOps);
    12901394
    12911395static int
     1396VolumeDataOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1397             Tcl_Obj *CONST *objv)
     1398{
     1399    Tcl_ObjCmdProc *proc;
     1400
     1401    proc = Rappture::GetOpFromObj(interp, nVolumeDataOps, volumeDataOps,
     1402                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
     1403    if (proc == NULL) {
     1404        return TCL_ERROR;
     1405    }
     1406    return (*proc) (cdata, interp, objc, objv);
     1407}
     1408
     1409static int
     1410VolumeOutlineColorOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1411                     Tcl_Obj *CONST *objv)
     1412{
     1413    float rgb[3];
     1414    if (GetColor(interp, objc - 3, objv + 3, rgb) != TCL_OK) {
     1415        return TCL_ERROR;
     1416    }
     1417    vector<Volume *> ivol;
     1418    if (GetVolumes(interp, objc - 6, objv + 6, &ivol) != TCL_OK) {
     1419        return TCL_ERROR;
     1420    }
     1421    vector<Volume *>::iterator iter;
     1422    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1423        (*iter)->set_outline_color(rgb);
     1424    }
     1425    return TCL_OK;
     1426}
     1427
     1428static int
    12921429VolumeOutlineStateOp(ClientData cdata, Tcl_Interp *interp, int objc,
    1293                   Tcl_Obj *CONST *objv)
    1294 {
    1295     return TCL_OK;
    1296 }
     1430                     Tcl_Obj *CONST *objv)
     1431{
     1432    bool state;
     1433    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
     1434        return TCL_ERROR;
     1435    }
     1436    vector<Volume *> ivol;
     1437    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     1438        return TCL_ERROR;
     1439    }
     1440    if (state) {
     1441        vector<Volume *>::iterator iter;
     1442        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1443            (*iter)->enable_outline();
     1444        }
     1445    } else {
     1446        vector<Volume *>::iterator iter;
     1447        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1448            (*iter)->disable_outline();
     1449        }
     1450    }
     1451    return TCL_OK;
     1452}
     1453
     1454static int
     1455VolumeOutlineVisibleOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1456                       Tcl_Obj *CONST *objv)
     1457{
     1458    bool visible;
     1459    if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
     1460        return TCL_ERROR;
     1461    }           
     1462    if (!visible) {
     1463        for (int i = 0; i < NanoVis::n_volumes; ++i) {
     1464            if (NanoVis::volume[i]) {
     1465                NanoVis::volume[i]->disable_outline();
     1466            }
     1467        }
     1468    } else {
     1469        for (int i = 0; i < NanoVis::n_volumes; ++i) {
     1470            if (NanoVis::volume[i]) {
     1471                NanoVis::volume[i]->enable_outline();
     1472            }
     1473        }
     1474    }
     1475    return TCL_OK;
     1476}
     1477
    12971478static Rappture::CmdSpec volumeOutlineOps[] =
    1298 {
    1299     {"color",     1, VolumeOutlineColorOp,    6, 0, "r g b ?indices?",},
    1300     {"state",     1, VolumeOutlineStateOp,    4, 0, "bool ?indices?",},
    1301     {"visible",   1, VolumeOutlineVisibleOp,  4, 0, "bool ?indices?",},
    1302 };
     1479    {
     1480        {"color",     1, VolumeOutlineColorOp,    6, 0, "r g b ?indices?",},
     1481        {"state",     1, VolumeOutlineStateOp,    4, 0, "bool ?indices?",},
     1482        {"visible",   1, VolumeOutlineVisibleOp,  4, 0, "bool ?indices?",},
     1483    };
    13031484static int nVolumeOutlineOps = NumCmdSpecs(volumeOutlineOps);
    13041485
     1486static int
     1487VolumeOutlineOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1488                Tcl_Obj *CONST *objv)
     1489{
     1490    Tcl_ObjCmdProc *proc;
     1491
     1492    proc = Rappture::GetOpFromObj(interp, nVolumeOutlineOps, volumeOutlineOps,
     1493                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
     1494    if (proc == NULL) {
     1495        return TCL_ERROR;
     1496    }
     1497    return (*proc) (cdata, interp, objc, objv);
     1498}
     1499
     1500static int
     1501VolumeShadingDiffuseOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1502                       Tcl_Obj *CONST *objv)
     1503{
     1504    float diffuse;
     1505    if (GetFloatFromObj(interp, objv[3], &diffuse) != TCL_OK) {
     1506        return TCL_ERROR;
     1507    }
     1508    vector<Volume *> ivol;
     1509    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     1510        return TCL_ERROR;
     1511    }
     1512    vector<Volume *>::iterator iter;
     1513    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1514        (*iter)->set_diffuse(diffuse);
     1515    }
     1516    return TCL_OK;
     1517}
     1518
     1519static int
     1520VolumeShadingIsosurfaceOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1521                          Tcl_Obj *CONST *objv)
     1522{
     1523    bool iso_surface;
     1524    if (GetBooleanFromObj(interp, objv[3], &iso_surface) != TCL_OK) {
     1525        return TCL_ERROR;
     1526    }
     1527    vector<Volume *> ivol;
     1528    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     1529        return TCL_ERROR;
     1530    }
     1531    vector<Volume *>::iterator iter;
     1532    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1533        (*iter)->set_isosurface(iso_surface);
     1534    }
     1535    return TCL_OK;
     1536}
     1537
     1538static int
     1539VolumeShadingOpacityOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1540                       Tcl_Obj *CONST *objv)
     1541{
     1542    float opacity;
     1543    if (GetFloatFromObj(interp, objv[3], &opacity) != TCL_OK) {
     1544        return TCL_ERROR;
     1545    }
     1546    vector<Volume *> ivol;
     1547    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     1548        return TCL_ERROR;
     1549    }
     1550    vector<Volume *>::iterator iter;
     1551    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1552        (*iter)->set_opacity_scale(opacity);
     1553    }
     1554    return TCL_OK;
     1555}
     1556
     1557static int
     1558VolumeShadingSpecularOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1559                        Tcl_Obj *CONST *objv)
     1560{
     1561    float specular;
     1562    if (GetFloatFromObj(interp, objv[3], &specular) != TCL_OK) {
     1563        return TCL_ERROR;
     1564    }
     1565    vector<Volume *> ivol;
     1566    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     1567        return TCL_ERROR;
     1568    }
     1569    vector<Volume *>::iterator iter;
     1570    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1571        (*iter)->set_specular(specular);
     1572    }
     1573    return TCL_OK;
     1574}
     1575
     1576static int
     1577VolumeShadingTransFuncOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1578                         Tcl_Obj *CONST *objv)
     1579{
     1580    TransferFunction *tf;
     1581    char *name = Tcl_GetString(objv[3]);
     1582    tf = NanoVis::get_transfunc(name);
     1583    if (tf == NULL) {
     1584        Tcl_AppendResult(interp, "transfer function \"", name,
     1585                         "\" is not defined", (char*)NULL);
     1586        return TCL_ERROR;
     1587    }
     1588    vector<Volume *> ivol;
     1589    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     1590        return TCL_ERROR;
     1591    }
     1592    vector<Volume *>::iterator iter;
     1593    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1594        NanoVis::vol_renderer->shade_volume(*iter, tf);
     1595#ifdef POINTSET
     1596        // TBD..
     1597        // POINTSET
     1598        if ((*iter)->pointsetIndex != -1) {
     1599            g_pointSet[(*iter)->pointsetIndex]->updateColor(tf->getData(), 256);
     1600        }
     1601#endif /*POINTSET*/
     1602    }
     1603    return TCL_OK;
     1604}
     1605
    13051606static Rappture::CmdSpec volumeShadingOps[] =
    1306 {
    1307     {"diffuse",     1, VolumeShadingDiffuseOp,    4, 0, "value ?indices?",},
    1308     {"isosurface",  1, VolumeShadingIsosurfaceOp, 4, 0, "bool ?indices?",},
    1309     {"opacity",     1, VolumeShadingOpacityOp,    4, 0, "value ?indices?",},
    1310     {"specular",    1, VolumeShadingSpecularOp,   4, 0, "value ?indices?",},
    1311     {"transfunc",   1, VolumeShadingTransFuncOp,  4, 0, "funcName ?indices?",},
    1312 };
     1607    {
     1608        {"diffuse",     1, VolumeShadingDiffuseOp,    4, 0, "value ?indices?",},
     1609        {"isosurface",  1, VolumeShadingIsosurfaceOp, 4, 0, "bool ?indices?",},
     1610        {"opacity",     1, VolumeShadingOpacityOp,    4, 0, "value ?indices?",},
     1611        {"specular",    1, VolumeShadingSpecularOp,   4, 0, "value ?indices?",},
     1612        {"transfunc",   1, VolumeShadingTransFuncOp,  4, 0, "funcName ?indices?",},
     1613    };
    13131614static int nVolumeShadingOps = NumCmdSpecs(volumeShadingOps);
    13141615
     1616static int
     1617VolumeShadingOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1618                Tcl_Obj *CONST *objv)
     1619{
     1620    Tcl_ObjCmdProc *proc;
     1621
     1622    proc = Rappture::GetOpFromObj(interp, nVolumeShadingOps, volumeShadingOps,
     1623                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
     1624    if (proc == NULL) {
     1625        return TCL_ERROR;
     1626    }
     1627    return (*proc) (cdata, interp, objc, objv);
     1628}
     1629
     1630static int
     1631VolumeAxisOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1632             Tcl_Obj *CONST *objv)
     1633{
     1634    char *string = Tcl_GetString(objv[2]);
     1635    char c;
     1636    c = string[0];
     1637    if ((c == 'l') && (strcmp(string, "label") == 0)) {
     1638        int axis;
     1639        if (GetAxisFromObj(interp, objv[3], &axis) != TCL_OK) {
     1640            return TCL_ERROR;
     1641        }
     1642        vector<Volume *> ivol;
     1643        if (GetVolumes(interp, objc - 5, objv + 5, &ivol) != TCL_OK) {
     1644            return TCL_ERROR;
     1645        }
     1646        vector<Volume *>::iterator iter;
     1647        char *label;
     1648        label = Tcl_GetString(objv[4]);
     1649        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1650            (*iter)->set_label(axis, label);
     1651        }
     1652    } else {
     1653        Tcl_AppendResult(interp, "bad option \"", string,
     1654                         "\": should be label", (char*)NULL);
     1655        return TCL_ERROR;
     1656    }
     1657    return TCL_OK;
     1658}
     1659
     1660static int
     1661VolumeStateOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1662              Tcl_Obj *CONST *objv)
     1663{
     1664    bool state;
     1665    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     1666        return TCL_ERROR;
     1667    }
     1668    vector<Volume *> ivol;
     1669    if (GetVolumes(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
     1670        return TCL_ERROR;
     1671    }
     1672    if (state) {
     1673        vector<Volume *>::iterator iter;
     1674        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1675            (*iter)->enable();
     1676        }
     1677    } else {
     1678        vector<Volume *>::iterator iter;
     1679        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
     1680            (*iter)->disable();
     1681        }
     1682    }
     1683    return TCL_OK;
     1684}
     1685
     1686static int
     1687VolumeTestOp(ClientData cdata, Tcl_Interp *interp, int objc,
     1688             Tcl_Obj *CONST *objv)
     1689{
     1690    NanoVis::volume[1]->disable_data();
     1691    NanoVis::volume[1]->disable();
     1692    return TCL_OK;
     1693}
     1694
    13151695static Rappture::CmdSpec volumeOps[] =
    1316 {
    1317     {"animation", 2, VolumeAnimationOp,   3, 3, "oper ?args?",},
    1318     {"axis",      2, VolumeAxisOp,        3, 3, "label axis value ?indices?",},
    1319     {"data",      1, VolumeDataOp,        3, 3, "oper ?args?",},
    1320     {"outline",   1, VolumeOutlineOp,     3, 0, "oper ?args?",},
    1321     {"shading",   2, VolumeShadingOp,     3, 0, "oper ?args?",},
    1322     {"state",     2, VolumeStateOp,       3, 0, "bool ?indices?",},
    1323     {"test2",     1, VolumeTestOp,        2, 2, "",},
    1324 };
     1696    {
     1697        {"animation", 2, VolumeAnimationOp,   3, 3, "oper ?args?",},
     1698        {"axis",      2, VolumeAxisOp,        3, 3, "label axis value ?indices?",},
     1699        {"data",      1, VolumeDataOp,        3, 3, "oper ?args?",},
     1700        {"outline",   1, VolumeOutlineOp,     3, 0, "oper ?args?",},
     1701        {"shading",   2, VolumeShadingOp,     3, 0, "oper ?args?",},
     1702        {"state",     2, VolumeStateOp,       3, 0, "bool ?indices?",},
     1703        {"test2",     1, VolumeTestOp,        2, 2, "",},
     1704    };
    13251705static int nVolumeOps = NumCmdSpecs(volumeOps);
    1326 #endif
    13271706
    13281707/*
    … …  
    13451724VolumeCmd(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv)
    13461725{
     1726    Tcl_ObjCmdProc *proc;
     1727
     1728    proc = Rappture::GetOpFromObj(interp, nVolumeOps, volumeOps,
     1729                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
     1730    if (proc == NULL) {
     1731        return TCL_ERROR;
     1732    }
     1733    return (*proc) (cdata, interp, objc, objv);
     1734}
     1735
     1736#else
     1737
     1738static int
     1739VolumeCmd(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv)
     1740{
    13471741    if (objc < 2) {
    13481742        Tcl_AppendResult(interp, "wrong # args: should be \"",
    1349                 Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
     1743                        Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
    13501744        return TCL_ERROR;
    13511745    }
    … …  
    13561750        if (objc < 3) {
    13571751            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1358                 Tcl_GetString(objv[0]), " axis option ?arg arg...?\"",
    1359                 (char*)NULL);
     1752                             Tcl_GetString(objv[0]), " axis option ?arg arg...?\"",
     1753                             (char*)NULL);
    13601754            return TCL_ERROR;
    13611755        }
    … …  
    13651759            if (objc < 5) {
    13661760                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1367                         Tcl_GetString(objv[0]),
    1368                         " axis label x|y|z string ?volume ...?\"", (char*)NULL);
     1761                                Tcl_GetString(objv[0]),
     1762                                " axis label x|y|z string ?volume ...?\"", (char*)NULL);
    13691763                return TCL_ERROR;
    13701764            }
    … …  
    13851779        } else {
    13861780            Tcl_AppendResult(interp, "bad option \"", string,
    1387                 "\": should be label", (char*)NULL);
     1781                             "\": should be label", (char*)NULL);
    13881782            return TCL_ERROR;
    13891783        }
    … …  
    13911785        if (objc < 3) {
    13921786            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1393                 Tcl_GetString(objv[0]), " data option ?arg arg...?\"",
    1394                 (char*)NULL);
     1787                             Tcl_GetString(objv[0]), " data option ?arg arg...?\"",
     1788                             (char*)NULL);
    13951789            return TCL_ERROR;
    13961790        }
    … …  
    14001794            if (objc < 4) {
    14011795                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1402                         Tcl_GetString(objv[0])," data state on|off ?volume...?\"",
    1403                         (char*)NULL);
    1404                 return TCL_ERROR;
    1405             }
    1406             int state;
    1407             if (Tcl_GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
     1796                                Tcl_GetString(objv[0])," data state on|off ?volume...?\"",
     1797                                (char*)NULL);
     1798                return TCL_ERROR;
     1799            }
     1800            bool state;
     1801            if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
    14081802                return TCL_ERROR;
    14091803            }
    … …  
    14261820            if (objc < 4) {
    14271821                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1428                         Tcl_GetString(objv[0]), " data follows size", (char*)NULL);
     1822                                Tcl_GetString(objv[0]), " data follows size", (char*)NULL);
    14291823                return TCL_ERROR;
    14301824            }
    … …  
    15721966        } else {
    15731967            Tcl_AppendResult(interp, "bad data option \"", string,
    1574                 "\": should be follows or state", (char*)NULL);
     1968                             "\": should be follows or state", (char*)NULL);
    15751969            return TCL_ERROR;
    15761970        }
    … …  
    15781972        if (objc < 3) {
    15791973            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1580                 Tcl_GetString(objv[0]), " outline option ?arg arg...?\"",
    1581                 (char*)NULL);
     1974                             Tcl_GetString(objv[0]), " outline option ?arg arg...?\"",
     1975                             (char*)NULL);
    15821976            return TCL_ERROR;
    15831977        }
    … …  
    15871981            if (objc < 3) {
    15881982                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1589                         Tcl_GetString(objv[0]),
    1590                         " outline state on|off ?volume ...? \"", (char*)NULL);
    1591                 return TCL_ERROR;
    1592             }
    1593 
    1594             int state;
    1595             if (Tcl_GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
     1983                                Tcl_GetString(objv[0]),
     1984                                " outline state on|off ?volume ...? \"", (char*)NULL);
     1985                return TCL_ERROR;
     1986            }
     1987
     1988            bool state;
     1989            if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
    15961990                return TCL_ERROR;
    15971991            }
    … …  
    16122006            }
    16132007        } else if ((c == 'v') && (strcmp(string, "visible") == 0)) {
    1614             int ivisible;
    1615 
    1616             if (Tcl_GetBooleanFromObj(interp, objv[3], &ivisible) != TCL_OK) {
     2008            bool visible;
     2009
     2010            if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
    16172011                return TCL_ERROR;
    16182012            }           
    1619             if (!ivisible) {
     2013            if (!visible) {
    16202014                for (int i = 0; i < NanoVis::n_volumes; ++i) {
    16212015                    if (NanoVis::volume[i]) {
    … …  
    16332027            if (objc < 6) {
    16342028                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1635                         Tcl_GetString(objv[0]),
    1636                         " outline color R G B ?volume ...? \"", (char*)NULL);
     2029                                Tcl_GetString(objv[0]),
     2030                                " outline color R G B ?volume ...? \"", (char*)NULL);
    16372031                return TCL_ERROR;
    16382032            }
    … …  
    16522046        else {
    16532047            Tcl_AppendResult(interp, "bad outline option \"", string,
    1654                 "\": should be color, visible, or state", (char*)NULL);
     2048                             "\": should be color, visible, or state", (char*)NULL);
    16552049            return TCL_ERROR;
    16562050        }
    … …  
    16582052        if (objc < 3) {
    16592053            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1660                 Tcl_GetString(objv[0]), " shading option ?arg arg...?\"",
    1661                 (char*)NULL);
     2054                             Tcl_GetString(objv[0]), " shading option ?arg arg...?\"",
     2055                             (char*)NULL);
    16622056            return TCL_ERROR;
    16632057        }
    … …  
    16672061            if (objc < 4) {
    16682062                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1669                         Tcl_GetString(objv[0]),
    1670                         " shading transfunc name ?volume ...?\"", (char*)NULL);
     2063                                Tcl_GetString(objv[0]),
     2064                                " shading transfunc name ?volume ...?\"", (char*)NULL);
    16712065                return TCL_ERROR;
    16722066            }
    … …  
    16762070            if (tf == NULL) {
    16772071                Tcl_AppendResult(interp, "transfer function \"", name,
    1678                     "\" is not defined", (char*)NULL);
     2072                                "\" is not defined", (char*)NULL);
    16792073                return TCL_ERROR;
    16802074            }
    … …  
    16902084                // POINTSET
    16912085                /*
    1692                 if ((*iter)->pointsetIndex != -1) {
    1693                     g_pointSet[(*iter)->pointsetIndex]->updateColor(tf->getData(), 256);
    1694                 }
     2086                  if ((*iter)->pointsetIndex != -1) {
     2087                  g_pointSet[(*iter)->pointsetIndex]->updateColor(tf->getData(), 256);
     2088                  }
    16952089                */
    16962090            }
    … …  
    16982092            if (objc < 4) {
    16992093                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1700                         Tcl_GetString(objv[0]),
    1701                         " shading diffuse value ?volume ...?\"", (char*)NULL);
     2094                                Tcl_GetString(objv[0]),
     2095                                " shading diffuse value ?volume ...?\"", (char*)NULL);
    17022096                return TCL_ERROR;
    17032097            }
    … …  
    17182112            if (objc < 4) {
    17192113                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1720                         Tcl_GetString(objv[0]),
    1721                         " shading opacity value ?volume ...?\"", (char*)NULL);
     2114                                Tcl_GetString(objv[0]),
     2115                                " shading opacity value ?volume ...?\"", (char*)NULL);
    17222116                return TCL_ERROR;
    17232117            }
    … …  
    17372131            if (objc < 4) {
    17382132                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1739                         Tcl_GetString(objv[0]),
    1740                         " shading specular value ?volume ...?\"", (char*)NULL);
     2133                                Tcl_GetString(objv[0]),
     2134                                " shading specular value ?volume ...?\"", (char*)NULL);
    17412135                return TCL_ERROR;
    17422136            }
    … …  
    17562150            if (objc < 4) {
    17572151                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1758                         Tcl_GetString(objv[0]),
    1759                         " shading isosurface on|off ?volume ...?\"", (char*)NULL);
    1760                 return TCL_ERROR;
    1761             }
    1762             int iso_surface;
    1763             if (Tcl_GetBooleanFromObj(interp, objv[3], &iso_surface) != TCL_OK) {
     2152                                Tcl_GetString(objv[0]),
     2153                                " shading isosurface on|off ?volume ...?\"", (char*)NULL);
     2154                return TCL_ERROR;
     2155            }
     2156            bool iso_surface;
     2157            if (GetBooleanFromObj(interp, objv[3], &iso_surface) != TCL_OK) {
    17642158                return TCL_ERROR;
    17652159            }
    … …  
    17742168        } else {
    17752169            Tcl_AppendResult(interp, "bad shading option \"", string,
    1776                 "\": should be diffuse, opacity, specular, transfunc, or ",
    1777                 "isosurface", (char*)NULL);
     2170                             "\": should be diffuse, opacity, specular, transfunc, or ",
     2171                             "isosurface", (char*)NULL);
    17782172            return TCL_ERROR;
    17792173        }
    … …  
    17812175        if (objc < 3) {
    17822176            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1783                 Tcl_GetString(objv[0]), " state on|off ?volume...?\"",
    1784                 (char*)NULL);
    1785             return TCL_ERROR;
    1786         }
    1787         int state;
    1788         if (Tcl_GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     2177                             Tcl_GetString(objv[0]), " state on|off ?volume...?\"",
     2178                             (char*)NULL);
     2179            return TCL_ERROR;
     2180        }
     2181        bool state;
     2182        if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
    17892183            return TCL_ERROR;
    17902184        }
    … …  
    18072201        if (objc < 3) {
    18082202            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1809                 Tcl_GetString(objv[0]), " animation option ?args...?\"",
    1810                 (char*)NULL);
     2203                             Tcl_GetString(objv[0]), " animation option ?args...?\"",
     2204                             (char*)NULL);
    18112205            return TCL_ERROR;
    18122206        }
    … …  
    18232217                Trace("index: %d\n", *iter);
    18242218                NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volume[*iter],
    1825                         *iter);
     2219                                                        *iter);
    18262220            }
    18272221        } else if ((c == 'c') && (strcmp(string,"capture") == 0)) {
    … …  
    18622256        } else {
    18632257            Tcl_AppendResult(interp, "bad animation option \"", string,
    1864                 "\": should be volumes, start, stop,  or clear", (char*)NULL);
     2258                             "\": should be volumes, start, stop,  or clear", (char*)NULL);
    18652259            return TCL_ERROR;
    18662260        }
    … …  
    18702264    } else {
    18712265        Tcl_AppendResult(interp, "bad option \"", string, "\": should be ",
    1872                 "data, outline, shading, or state", (char*)NULL);
    1873         return TCL_ERROR;
    1874     }
    1875     return TCL_OK;
    1876 }
     2266                         "data, outline, shading, or state", (char*)NULL);
     2267        return TCL_ERROR;
     2268    }
     2269    return TCL_OK;
     2270}
     2271#endif
    18772272
    18782273static int
    … …  
    18832278    if (objc < 2) {
    18842279        Tcl_AppendResult(interp, "wrong # args: should be \"",
    1885                 Tcl_GetString(objv[0]), " option ?arg arg?", (char *)NULL);
     2280                        Tcl_GetString(objv[0]), " option ?arg arg?", (char *)NULL);
    18862281        return TCL_ERROR;
    18872282    }
    … …  
    18912286        if (objc != 3) {
    18922287            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1893                 Tcl_GetString(objv[0]), " vectorid volume", (char *)NULL);
     2288                             Tcl_GetString(objv[0]), " vectorid volume", (char *)NULL);
    18942289            return TCL_ERROR;
    18952290        }
    … …  
    19012296        if (NanoVis::particleRenderer != NULL) {
    19022297            NanoVis::particleRenderer->setVectorField(volPtr->id, 1.0f,
    1903                 volPtr->height / (float)volPtr->width,
    1904                 volPtr->depth  / (float)volPtr->width,
    1905                 volPtr->range_max());
     2298                                                      volPtr->height / (float)volPtr->width,
     2299                                                      volPtr->depth  / (float)volPtr->width,
     2300                                                      volPtr->range_max());
    19062301            NanoVis::initParticle();
    19072302        }
    19082303        if (NanoVis::licRenderer != NULL) {
    19092304            NanoVis::licRenderer->setVectorField(volPtr->id,
    1910                 1.0f / volPtr->aspect_ratio_width,
    1911                 1.0f / volPtr->aspect_ratio_height,
    1912                 1.0f / volPtr->aspect_ratio_depth,
    1913                 volPtr->range_max());
     2305                                                1.0f / volPtr->aspect_ratio_width,
     2306                                                1.0f / volPtr->aspect_ratio_height,
     2307                                                1.0f / volPtr->aspect_ratio_depth,
     2308                                                volPtr->range_max());
    19142309            NanoVis::licRenderer->set_offset(NanoVis::lic_slice_z);
    19152310        }
    … …  
    19172312        if (objc != 3) {
    19182313            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1919                 Tcl_GetString(objv[0]), " lic on|off\"", (char*)NULL);
    1920             return TCL_ERROR;
    1921         }
    1922         int ibool;
    1923         if (Tcl_GetBooleanFromObj(interp, objv[2], &ibool) != TCL_OK) {
    1924             return TCL_ERROR;
    1925         }
    1926         NanoVis::lic_on = (bool)ibool;
     2314                             Tcl_GetString(objv[0]), " lic on|off\"", (char*)NULL);
     2315            return TCL_ERROR;
     2316        }
     2317        bool state;
     2318        if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     2319            return TCL_ERROR;
     2320        }
     2321        NanoVis::lic_on = state;
    19272322    } else if ((c == 'p') && (strcmp(string, "particle") == 0)) {
    19282323        if (objc < 3) {
    19292324            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1930                 Tcl_GetString(objv[0]), " particle visible|slice|slicepos arg \"",
    1931                 (char*)NULL);
     2325                             Tcl_GetString(objv[0]), " particle visible|slice|slicepos arg \"",
     2326                             (char*)NULL);
    19322327            return TCL_ERROR;
    19332328        }
    … …  
    19372332            if (objc != 4) {
    19382333                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1939                         Tcl_GetString(objv[0]), " particle visible on|off\"",
    1940                         (char*)NULL);
    1941                 return TCL_ERROR;
    1942             }
    1943             int state;
    1944             if (Tcl_GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
     2334                                Tcl_GetString(objv[0]), " particle visible on|off\"",
     2335                                (char*)NULL);
     2336                return TCL_ERROR;
     2337            }
     2338            bool state;
     2339            if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
    19452340                return TCL_ERROR;
    19462341            }
    … …  
    19492344            if (objc != 4) {
    19502345                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1951                         Tcl_GetString(objv[0]),
    1952                         " particle slice volume\"", (char*)NULL);
     2346                                Tcl_GetString(objv[0]),
     2347                                " particle slice volume\"", (char*)NULL);
    19532348                return TCL_ERROR;
    19542349            }
    … …  
    19612356            if (objc != 4) {
    19622357                Tcl_AppendResult(interp, "wrong # args: should be \"",
    1963                         Tcl_GetString(objv[0]), " particle slicepos value\"",
    1964                         (char*)NULL);
     2358                                Tcl_GetString(objv[0]), " particle slicepos value\"",
     2359                                (char*)NULL);
    19652360                return TCL_ERROR;
    19662361            }
    … …  
    19872382        } else {
    19882383            Tcl_AppendResult(interp, "unknown option \"",string,"\": should be \"",
    1989                 Tcl_GetString(objv[0]), " visible, slice, or slicepos\"",
    1990                 (char *)NULL);
     2384                             Tcl_GetString(objv[0]), " visible, slice, or slicepos\"",
     2385                             (char *)NULL);
    19912386            return TCL_ERROR;
    19922387        }
    … …  
    19962391        if (objc > 4 || objc < 3) {
    19972392            Tcl_AppendResult(interp, "wrong # args: should be \"",
    1998                 Tcl_GetString(objv[0]), " capture numframes [directory]\"",
    1999                 (char*)NULL);
     2393                             Tcl_GetString(objv[0]), " capture numframes [directory]\"",
     2394                             (char*)NULL);
    20002395            return TCL_ERROR;
    20012396        }
    … …  
    20502445        if (objc < 3) {
    20512446            Tcl_AppendResult(interp, "wrong # args: should be \"",
    2052                 Tcl_GetString(objv[0]), " data follows ?args?", (char *)NULL);
     2447                             Tcl_GetString(objv[0]), " data follows ?args?", (char *)NULL);
    20532448            return TCL_ERROR;
    20542449        }
    … …  
    20582453            if (objc != 4) {
    20592454                Tcl_AppendResult(interp, "wrong # args: should be \"",
    2060                         Tcl_GetString(objv[0]), " data follows length",
    2061                         (char *)NULL);
     2455                                Tcl_GetString(objv[0]), " data follows length",
     2456                                (char *)NULL);
    20622457                return TCL_ERROR;
    20632458            }
    … …  
    20912486
    20922487                NanoVis::vol_renderer->add_volume(volPtr,
    2093                         NanoVis::get_transfunc("default"));
     2488                                                  NanoVis::get_transfunc("default"));
    20942489            }
    20952490        }
    … …  
    21292524                       Tcl_Obj *CONST *objv)
    21302525{
    2131     int ivisible;
    2132     if (Tcl_GetBooleanFromObj(interp, objv[3], &ivisible) != TCL_OK) {
     2526    bool visible;
     2527    if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
    21332528        return TCL_ERROR;
    21342529    }
    … …  
    21372532        return TCL_ERROR;
    21382533    }
    2139     bool visible;
    2140     visible = (bool)ivisible;
    21412534    for (unsigned int i = 0; i < indices.size(); ++i) {
    21422535        if ((indices[i] < NanoVis::heightMap.size()) &&
    … …  
    21492542
    21502543static Rappture::CmdSpec heightMapDataOps[] =
    2151 {
    2152     {"follows",      1, HeightMapDataFollowsOp, 4, 4, "length",},
    2153     {"visible",      1, HeightMapDataVisibleOp, 4, 0, "bool ?indices?",},
    2154 };
     2544    {
     2545        {"follows",      1, HeightMapDataFollowsOp, 4, 4, "length",},
     2546        {"visible",      1, HeightMapDataVisibleOp, 4, 0, "bool ?indices?",},
     2547    };
    21552548static int nHeightMapDataOps = NumCmdSpecs(heightMapDataOps);
    21562549
    21572550static int
    21582551HeightMapDataOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2159                  Tcl_Obj *CONST *objv)
     2552                Tcl_Obj *CONST *objv)
    21602553{
    21612554    Tcl_ObjCmdProc *proc;
    21622555
    21632556    proc = Rappture::GetOpFromObj(interp, nHeightMapDataOps, heightMapDataOps,
    2164                 Rappture::CMDSPEC_ARG2, objc, objv, 0);
     2557                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
    21652558    if (proc == NULL) {
    21662559        return TCL_ERROR;
    … …  
    21722565static int
    21732566HeightMapLineContourColorOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2174                               Tcl_Obj *CONST *objv)
     2567                            Tcl_Obj *CONST *objv)
    21752568{
    21762569    float rgb[3];
    … …  
    21952588                              Tcl_Obj *CONST *objv)
    21962589{
    2197     int ivisible;
    21982590    bool visible;
    2199     if (Tcl_GetBooleanFromObj(interp, objv[3], &ivisible) != TCL_OK) {
    2200         return TCL_ERROR;
    2201     }
    2202     visible = (bool)ivisible;
     2591    if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
     2592        return TCL_ERROR;
     2593    }
    22032594    vector<unsigned int> indices;
    22042595    if (GetIndices(interp, objc-4, objv+4, &indices) != TCL_OK) {
    … …  
    22152606
    22162607static Rappture::CmdSpec heightMapLineContourOps[] =
    2217 {
    2218     {"color",   1, HeightMapLineContourColorOp,   4, 4, "length",},
    2219     {"visible", 1, HeightMapLineContourVisibleOp, 4, 0, "bool ?indices?",},
    2220 };
     2608    {
     2609        {"color",   1, HeightMapLineContourColorOp,   4, 4, "length",},
     2610        {"visible", 1, HeightMapLineContourVisibleOp, 4, 0, "bool ?indices?",},
     2611    };
    22212612static int nHeightMapLineContourOps = NumCmdSpecs(heightMapLineContourOps);
    22222613
    22232614static int
    22242615HeightMapLineContourOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2225                         Tcl_Obj *CONST *objv)
     2616                       Tcl_Obj *CONST *objv)
    22262617{
    22272618    Tcl_ObjCmdProc *proc;
    22282619
    22292620    proc = Rappture::GetOpFromObj(interp, nHeightMapLineContourOps,
    2230         heightMapLineContourOps, Rappture::CMDSPEC_ARG2, objc, objv, 0);
     2621                                  heightMapLineContourOps, Rappture::CMDSPEC_ARG2, objc, objv, 0);
    22312622    if (proc == NULL) {
    22322623        return TCL_ERROR;
    … …  
    22372628static int
    22382629HeightMapCullOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2239                    Tcl_Obj *CONST *objv)
     2630                Tcl_Obj *CONST *objv)
    22402631{
    22412632    graphics::RenderContext::CullMode mode;
    … …  
    22752666    if (tf == NULL) {
    22762667        Tcl_AppendResult(interp, "no transfer function defined for heightmap \"",
    2277                 Tcl_GetString(objv[2]), "\"", (char*)NULL);
     2668                        Tcl_GetString(objv[2]), "\"", (char*)NULL);
    22782669        return TCL_ERROR;
    22792670    }
    … …  
    23022693static int
    23032694HeightMapShadeOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2304                   Tcl_Obj *CONST *objv)
     2695                Tcl_Obj *CONST *objv)
    23052696{
    23062697    graphics::RenderContext::ShadingModel model;
    … …  
    23142705static int
    23152706HeightMapTestOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2316         Tcl_Obj *CONST *objv)
     2707                Tcl_Obj *CONST *objv)
    23172708{
    23182709    srand((unsigned)time(NULL));
    … …  
    23782769
    23792770static Rappture::CmdSpec heightMapOps[] =
    2380 {
    2381     {"create",       2, HeightMapCreateOp,      9, 9,
    2382         "xmin ymin xmax ymax xnum ynum values",},
    2383     {"cull",         2, HeightMapCullOp,        3, 3, "mode",},
    2384     {"data",         1, HeightMapDataOp,        3, 0, "oper ?args?",},
    2385     {"legend",       2, HeightMapLegendOp,      5, 5, "index width height",},
    2386     {"linecontour",  2, HeightMapLineContourOp, 2, 0, "oper ?args?",},
    2387     {"polygon",      1, HeightMapPolygonOp,     3, 3, "mode",},
    2388     {"shade",        1, HeightMapShadeOp,       3, 3, "model",},
    2389     {"test",         2, HeightMapTestOp,        2, 2, "",},
    2390     {"transfunc",    2, HeightMapTransFuncOp,   3, 0, "name ?indices?",},
    2391 };
     2771    {
     2772        {"create",       2, HeightMapCreateOp,      9, 9,
     2773        "xmin ymin xmax ymax xnum ynum values",},
     2774        {"cull",         2, HeightMapCullOp,        3, 3, "mode",},
     2775        {"data",         1, HeightMapDataOp,        3, 0, "oper ?args?",},
     2776        {"legend",       2, HeightMapLegendOp,      5, 5, "index width height",},
     2777        {"linecontour",  2, HeightMapLineContourOp, 2, 0, "oper ?args?",},
     2778        {"polygon",      1, HeightMapPolygonOp,     3, 3, "mode",},
     2779        {"shade",        1, HeightMapShadeOp,       3, 3, "model",},
     2780        {"test",         2, HeightMapTestOp,        2, 2, "",},
     2781        {"transfunc",    2, HeightMapTransFuncOp,   3, 0, "name ?indices?",},
     2782    };
    23922783static int nHeightMapOps = NumCmdSpecs(heightMapOps);
    23932784
    … …  
    23982789
    23992790    proc = Rappture::GetOpFromObj(interp, nHeightMapOps, heightMapOps,
    2400         Rappture::CMDSPEC_ARG1, objc, objv, 0);
     2791                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
    24012792    if (proc == NULL) {
    24022793        return TCL_ERROR;
    … …  
    24272818static int
    24282819GridAxisNameOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2429                 Tcl_Obj *CONST *objv)
     2820               Tcl_Obj *CONST *objv)
    24302821{
    24312822    int axisId;
    … …  
    24772868
    24782869static int
    2479 GridMinMaxOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2480              Tcl_Obj *CONST *objv)
     2870GridMinMaxOp(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv)
    24812871{
    24822872    double x1, y1, z1, x2, y2, z2;
    … …  
    24962886
    24972887static int
    2498 GridVisibleOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2499              Tcl_Obj *CONST *objv)
    2500 {
    2501     int ivisible;
    2502    
    2503     if (Tcl_GetBooleanFromObj(interp, objv[2], &ivisible) != TCL_OK) {
    2504         return TCL_ERROR;
    2505     }
    2506     NanoVis::grid->setVisible((bool)ivisible);
     2888GridVisibleOp(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv)
     2889{
     2890    bool visible;
     2891    if (GetBooleanFromObj(interp, objv[2], &visible) != TCL_OK) {
     2892        return TCL_ERROR;
     2893    }
     2894    NanoVis::grid->setVisible(visible);
    25072895    return TCL_OK;
    25082896}
    25092897
    25102898static Rappture::CmdSpec gridOps[] =
    2511 {
    2512     {"axiscolor",  5, GridAxisColorOp,  5, 6, "r g b ?a?",},
    2513     {"axisname",   5, GridAxisNameOp,   5, 5, "index width height",},
    2514     {"linecolor",  7, GridLineColorOp,  5, 6, "r g b ?a?",},
    2515     {"linecount",  7, GridLineCountOp,  5, 5, "xCount yCount zCount",},
    2516     {"minmax",     1, GridMinMaxOp,     8, 8, "xMin yMin zMin xMax yMax zMax",},
    2517     {"visible",    1, GridVisibleOp,    3, 3, "bool",},
    2518 };
     2899    {
     2900        {"axiscolor",  5, GridAxisColorOp,  5, 6, "r g b ?a?",},
     2901        {"axisname",   5, GridAxisNameOp,   5, 5, "index width height",},
     2902        {"linecolor",  7, GridLineColorOp,  5, 6, "r g b ?a?",},
     2903        {"linecount",  7, GridLineCountOp,  5, 5, "xCount yCount zCount",},
     2904        {"minmax",     1, GridMinMaxOp,     8, 8, "xMin yMin zMin xMax yMax zMax",},
     2905        {"visible",    1, GridVisibleOp,    3, 3, "bool",},
     2906    };
    25192907static int nGridOps = NumCmdSpecs(gridOps);
    25202908
    … …  
    25252913
    25262914    proc = Rappture::GetOpFromObj(interp, nGridOps, gridOps,
    2527         Rappture::CMDSPEC_ARG1, objc, objv, 0);
     2915                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
    25282916    if (proc == NULL) {
    25292917        return TCL_ERROR;
    … …  
    25372925    if (objc < 2) {
    25382926        Tcl_AppendResult(interp, "wrong # args: should be \"",
    2539                 Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
     2927                        Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
    25402928        return TCL_ERROR;
    25412929    }
    … …  
    25432931    char c = string[0];
    25442932    if ((c == 'v') && (strcmp(string, "visible") == 0)) {
    2545         int ivisible;
    2546 
    2547         if (Tcl_GetBooleanFromObj(interp, objv[2], &ivisible) != TCL_OK) {
    2548             return TCL_ERROR;
    2549         }
    2550         NanoVis::axis_on = (bool)ivisible;
     2933        bool visible;
     2934
     2935        if (GetBooleanFromObj(interp, objv[2], &visible) != TCL_OK) {
     2936            return TCL_ERROR;
     2937        }
     2938        NanoVis::axis_on = visible;
    25512939    } else {
    25522940        Tcl_AppendResult(interp, "bad axis option \"", string,
    … …  
    25592947#if PLANE_CMD
    25602948static int
    2561 PlaneNewOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2562             Tcl_Obj *CONST *objv)
     2949PlaneNewOp(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj *CONST *objv)
    25632950{
    25642951    fprintf(stderr, "load plane for 2D visualization command\n");
    … …  
    25662953    if (objc != 4) {
    25672954        Tcl_AppendResult(interp, "wrong # args: should be \"",
    2568                 Tcl_GetString(objv[0]), " plane_index w h \"", (char*)NULL);
     2955                        Tcl_GetString(objv[0]), " plane_index w h \"", (char*)NULL);
    25692956        return TCL_ERROR;
    25702957    }
    … …  
    25992986static int
    26002987PlaneLinkOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2601              Tcl_Obj *CONST *objv)
     2988            Tcl_Obj *CONST *objv)
    26022989{
    26032990    fprintf(stderr, "link the plane to the 2D renderer command\n");
    … …  
    26072994    if (objc != 3) {
    26082995        Tcl_AppendResult(interp, "wrong # args: should be \"",
    2609                 Tcl_GetString(objv[0]), " plane_index tf_index \"", (char*)NULL);
     2996                        Tcl_GetString(objv[0]), " plane_index tf_index \"", (char*)NULL);
    26102997        return TCL_ERROR;
    26112998    }
    … …  
    26243011static int
    26253012PlaneEnableOp(ClientData cdata, Tcl_Interp *interp, int objc,
    2626                Tcl_Obj *CONST *objv)
     3013              Tcl_Obj *CONST *objv)
    26273014{
    26283015    fprintf(stderr,"enable a plane so the 2D renderer can render it command\n");
    … …  
    26303017    if (objc != 3) {
    26313018        Tcl_AppendResult(interp, "wrong # args: should be \"",
    2632                 Tcl_GetString(objv[0]), " plane_index mode \"", (char*)NULL);
     3019                        Tcl_GetString(objv[0]), " plane_index mode \"", (char*)NULL);
    26333020        return TCL_ERROR;
    26343021    }
    … …  
    26493036
    26503037static Rappture::CmdSpec planeOps[] =
    2651 {
    2652     {"enable",     1, PlaneEnableOp,    4, 4, "planeIdx mode",},
    2653     {"link",       1, PlaneLinkOp,      4, 4, "planeIdx transfuncIdx",},
    2654     {"new",        1, PlaneNewOp,       5, 5, "planeIdx width height",},
    2655 };
     3038    {
     3039        {"enable",     1, PlaneEnableOp,    4, 4, "planeIdx mode",},
     3040        {"link",       1, PlaneLinkOp,      4, 4, "planeIdx transfuncIdx",},
     3041        {"new",        1, PlaneNewOp,       5, 5, "planeIdx width height",},
     3042    };
    26563043static int nPlaneOps = NumCmdSpecs(planeOps);
    26573044
    … …  
    26623049
    26633050    proc = Rappture::GetOpFromObj(interp, nPlaneOps, planeOps,
    2664         Rappture::CMDSPEC_ARG1, objc, objv, 0);
     3051                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
    26653052    if (proc == NULL) {
    26663053        return TCL_ERROR;
    … …  
    26913078    if ((objc & 0x01) == 0) {
    26923079        Tcl_AppendResult(interp, Tcl_GetString(objv[0]), ": ",
    2693                 "wrong number of arguments: should be key-value pairs",
    2694                 (char *)NULL);
     3080                        "wrong number of arguments: should be key-value pairs",
     3081                        (char *)NULL);
    26953082        return TCL_ERROR;
    26963083    }
    … …  
    27523139        } else {
    27533140            Tcl_AppendResult(interp, "unknown key \"", string,
    2754                 "\": should be xmin, xmax, xnum, ymin, ymax, ynum, or zvalues",
    2755                 (char *)NULL);
     3141                             "\": should be xmin, xmax, xnum, ymin, ymax, ynum, or zvalues",
     3142                             (char *)NULL);
    27563143            return TCL_ERROR;
    27573144        }
    … …  
    27633150    if (zNum != (xNum * yNum)) {
    27643151        Tcl_AppendResult(interp, "wrong number of z values must be xnum*ynum",
    2765                 (char *)NULL);
     3152                        (char *)NULL);
    27663153        return TCL_ERROR;
    27673154    }
    … …  
    28843271    //
    28853272    /*
    2886     if (NanoVis::licRenderer && NanoVis::licRenderer->isActivated())
    2887     {
    2888         NanoVis::licRenderer->convolve();
    2889     }
    2890 
    2891     if (NanoVis::particleRenderer && NanoVis::particleRenderer->isActivated())
    2892     {
    2893         NanoVis::particleRenderer->advect();
    2894     }
     3273      if (NanoVis::licRenderer && NanoVis::licRenderer->isActivated())
     3274      {
     3275      NanoVis::licRenderer->convolve();
     3276      }
     3277
     3278      if (NanoVis::particleRenderer && NanoVis::particleRenderer->isActivated())
     3279      {
     3280      NanoVis::particleRenderer->advect();
     3281      }
    28953282    */
    28963283
    … …  
    29033290    // INSOO
    29043291#ifdef XINETD
    2905    NanoVis::read_screen();
    2906    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     3292    NanoVis::read_screen();
     3293    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    29073294#else
    2908    NanoVis::display_offscreen_buffer(); //display the final rendering on screen
    2909    NanoVis::read_screen();
    2910    glutSwapBuffers();
     3295    NanoVis::display_offscreen_buffer(); //display the final rendering on screen
     3296    NanoVis::read_screen();
     3297    glutSwapBuffers();
    29113298#endif   
    29123299

  • trunk/vizservers/nanovis/HeightMap.cpp

    r862 r927  
     1 
    12#include <GL/glew.h>
    23#include <GL/gl.h>
    … …  
    1617
    1718HeightMap::HeightMap() :
     19    _vertexBufferObjectID(0),
     20    _textureBufferObjectID(0),
     21    _vertexCount(0),
    1822    _contour(0),
    1923    _colorMap(0),
    2024    _indexBuffer(0),
    2125    _indexCount(0),
    22     _vertexBufferObjectID(0),
    23     _vertexCount(0),
    24     _textureBufferObjectID(0),
     26    _contourColor(1.0f, 0.0f, 0.0f),
    2527    _contourVisible(true),
     28    _visible(false),
    2629    _scale(1.0f, 1.0f, 1.0f),
    27     _contourColor(1.0f, 0.0f, 0.0f),
    28     _visible(false),
     30    _centerPoint(0.0f, 0.0f, 0.0f),
    2931    _vmin(0.0f),
    30     _vmax(0.0f),
    31     _centerPoint(0.0f, 0.0f, 0.0f)
     32    _vmax(0.0f)
    3233{
    3334    _shader = new NvShader();
    … …  
    3536    R2string path = R2FilePath::getInstance()->getPath("heightcolor.cg");
    3637    if (path.getLength() == 0) {
    37         printf("ERROR : file not found %s\n", "heightcolor.cg");
     38        printf("ERROR : file not found %s\n", "heightcolor.cg");
    3839    }
    3940    _shader->loadFragmentProgram(path, "main");
    … …  
    4647
    4748    if (_shader) {
    48         delete _shader;
     49        delete _shader;
    4950    }
    5051
    … …  
    7475
    7576    if (_contour) {
    76         glDepthRange (0.001, 1.0);
    77     }
    78        
     77        glDepthRange (0.001, 1.0);
     78    }
     79       
    7980    glEnable(GL_DEPTH_TEST);
    8081
    8182    if (_vertexBufferObjectID) {
    82         glColor3f(1.0f, 1.0f, 1.0f);
    83         glShadeModel(GL_SMOOTH);
    84         glEnable(GL_BLEND);
    85         glEnableClientState(GL_VERTEX_ARRAY);
    86         glDisableClientState(GL_COLOR_ARRAY);
    87         glDisableClientState(GL_INDEX_ARRAY);
    88         glDisableClientState(GL_NORMAL_ARRAY);
    89        
    90         if (_colorMap) {
     83        glColor3f(1.0f, 1.0f, 1.0f);
     84        glShadeModel(GL_SMOOTH);
     85        glEnable(GL_BLEND);
     86        glEnableClientState(GL_VERTEX_ARRAY);
     87        glDisableClientState(GL_COLOR_ARRAY);
     88        glDisableClientState(GL_INDEX_ARRAY);
     89        glDisableClientState(GL_NORMAL_ARRAY);
     90       
     91        if (_colorMap) {
    9192            cgGLBindProgram(_shader->getFP());
    9293            cgGLEnableProfile(CG_PROFILE_FP30);
    93            
    94             cgGLSetTextureParameter(_tf, _colorMap->id);
    95             cgGLEnableTextureParameter(_tf);
    96            
    97             glEnable(GL_TEXTURE_1D);
    98             _colorMap->getTexture()->activate();
    99            
    100             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    101         }
    102        
    103         glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObjectID);
    104         glVertexPointer(3, GL_FLOAT, 12, 0);
    105        
    106         glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
    107         ::glTexCoordPointer(3, GL_FLOAT, 12, 0);
    108        
    109         glDrawElements(GL_TRIANGLES, _indexCount, GL_UNSIGNED_INT,
    110                        _indexBuffer);
    111         glBindBuffer(GL_ARRAY_BUFFER, 0);
    112        
    113         glDisableClientState(GL_VERTEX_ARRAY);
    114         if (_colorMap) {
    115             _colorMap->getTexture()->deactivate();
    116             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    117            
     94           
     95            cgGLSetTextureParameter(_tf, _colorMap->id);
     96            cgGLEnableTextureParameter(_tf);
     97           
     98            glEnable(GL_TEXTURE_1D);
     99            _colorMap->getTexture()->activate();
     100           
     101            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     102        }
     103       
     104        glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObjectID);
     105        glVertexPointer(3, GL_FLOAT, 12, 0);
     106       
     107        glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
     108        ::glTexCoordPointer(3, GL_FLOAT, 12, 0);
     109       
     110        glDrawElements(GL_TRIANGLES, _indexCount, GL_UNSIGNED_INT,
     111                       _indexBuffer);
     112        glBindBuffer(GL_ARRAY_BUFFER, 0);
     113       
     114        glDisableClientState(GL_VERTEX_ARRAY);
     115        if (_colorMap) {
     116            _colorMap->getTexture()->deactivate();
     117            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     118           
    118119            cgGLDisableProfile(CG_PROFILE_FP30);
    119         }
     120        }
    120121    }
    121122   
    … …  
    124125   
    125126    if (_contour && _contourVisible) {
    126         glDisable(GL_BLEND);
    127         glDisable(GL_TEXTURE_2D);
    128         glColor4f(_contourColor.x, _contourColor.y, _contourColor.z, 1.0f);
    129         glDepthRange (0.0, 0.999);
    130         _contour->render();
    131         glDepthRange (0.0, 1.0);
     127        glDisable(GL_BLEND);
     128        glDisable(GL_TEXTURE_2D);
     129        glColor4f(_contourColor.x, _contourColor.y, _contourColor.z, 1.0f);
     130        glDepthRange (0.0, 0.999);
     131        _contour->render();
     132        glDepthRange (0.0, 1.0);
    132133    }
    133134    glPopMatrix();
    … …  
    181182                *ptr = (i + 1) * xCount + j; ++ptr;
    182183                *ptr = (i + 1) * xCount + j + 1; ++ptr;
    183                 *ptr = i * xCount + j; ++ptr;
    184                 *ptr = (i + 1) * xCount + j + 1; ++ptr;
     184                *ptr = i * xCount + j; ++ptr;
     185                *ptr = (i + 1) * xCount + j + 1; ++ptr;
    185186                *ptr = i * xCount + j + 1; ++ptr;
    186187            }
    … …  
    192193{
    193194    if (_vertexBufferObjectID) {
    194         glDeleteBuffers(1, &_vertexBufferObjectID);
     195        glDeleteBuffers(1, &_vertexBufferObjectID);
    195196    }
    196197
    197198    if (_vertexBufferObjectID) {
    198         glDeleteBuffers(1, &_vertexBufferObjectID);
     199        glDeleteBuffers(1, &_vertexBufferObjectID);
    199200    }
    200201
    201202    //if (_contour) _contour->unrefDelete();
    202203    if (_contour) {
    203         delete _contour;
     204        delete _contour;
    204205    }
    205206    if (_indexBuffer) {
    206         free(_indexBuffer);
     207        free(_indexBuffer);
    207208    }
    208209}
    … …  
    216217    int count = xCount * yCount;
    217218    for (int i = 0; i < count; ++i) {
    218         if (_vmin > heights[i].y) {
    219             _vmin = heights[i].y;
    220         }
     219        if (_vmin > heights[i].y) {
     220            _vmin = heights[i].y;
     221        }
    221222        if (_vmax < heights[i].y) {
    222             _vmax = heights[i].y;
    223         }
     223            _vmax = heights[i].y;
     224        }
    224225    }
    225226
    … …  
    227228    _scale.z = _vmax - _vmin;
    228229    _scale.y = 1.0f;
     230    set_limits(0, 0.0, 1.0);
     231    set_limits(1, 0.0, 1.0);
     232    set_limits(2, _vmin, _vmax);
    229233
    230234    _centerPoint.set(_scale.x * 0.5, _scale.z * 0.5 + _vmin, _scale.y * 0.5);
    231235
    232     Vector3* texcoord = (Vector3*) malloc(count * sizeof(Vector3));
     236    Vector3* texcoord = new Vector3[count];
    233237    for (int i = 0; i < count; ++i) {
    234         texcoord[i].set(0, 0, heights[i].y);
     238        texcoord[i].set(0, 0, heights[i].y);
    235239    }
    236240   
    237241    glGenBuffers(1, &_vertexBufferObjectID);
    238242    glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObjectID);
    239     glBufferData(GL_ARRAY_BUFFER,
    240                  _vertexCount * sizeof( Vector3 ),
    241                  heights,
    242                  GL_STATIC_DRAW);
     243    glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof( Vector3 ), heights,
     244        GL_STATIC_DRAW);
    243245    glGenBuffers(1, &_textureBufferObjectID);
    244246    glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
    245     glBufferData(GL_ARRAY_BUFFER,
    246                  _vertexCount * sizeof(float) * 3,
    247                  texcoord,
    248                  GL_STATIC_DRAW);
     247    glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(float) * 3, texcoord,
     248        GL_STATIC_DRAW);
    249249    glBindBuffer(GL_ARRAY_BUFFER, 0);
    250250   
    251     free(texcoord);
     251    delete [] texcoord;
    252252   
    253253   
    … …  
    257257    //if (heightMap)
    258258    //{
    259     //  VertexBuffer* vertexBuffer = new VertexBuffer(VertexBuffer::POSITION3, xCount * yCount, sizeof(Vector3) * xCount * yCount, heightMap, false);
     259    //  VertexBuffer* vertexBuffer = new VertexBuffer(VertexBuffer::POSITION3, xCount * yCount, sizeof(Vector3) * xCount * yCount, heightMap, false);
    260260    if (_indexBuffer) {
    261         free(_indexBuffer);
     261        free(_indexBuffer);
    262262    }
    263263
    … …  
    271271
    272272void
    273 HeightMap::setHeight(
    274     float startX, float startY,
    275     float endX, float endY,
    276     int xCount, int yCount,
    277     float* heights)
     273HeightMap::setHeight(float startX, float startY, float endX, float endY,
     274                     int xCount, int yCount, float* heights)
    278275{
    279276    _vertexCount = xCount * yCount;
    280277   
    281278    reset();
    282    
     279
    283280    _vmin = heights[0], _vmax = heights[0];
    284281    int count = xCount * yCount;
    285282    for (int i = 0; i < count; ++i) {
    286         if (_vmin > heights[i]) {
    287             _vmin = heights[i];
    288         } else if (_vmax < heights[i]) {
    289             _vmax = heights[i];
    290         }
     283        if (_vmin > heights[i]) {
     284            _vmin = heights[i];
     285        } else if (_vmax < heights[i]) {
     286            _vmax = heights[i];
     287        }
    291288    }
    292289    _scale.x = endX - startX;
    293290    _scale.y = _vmax - _vmin;
    294291    _scale.z = endY - startY;
     292    set_limits(0, startX, endX);
     293    set_limits(1, startY, endY);
     294    set_limits(2, _vmin, _vmax);
    295295   
    296296    _centerPoint.set(_scale.x * 0.5 + startX, _scale.y * 0.5 + _vmin, _scale.z * 0.5 + startY);
    297297   
    298     Vector3* texcoord = (Vector3*) malloc(count * sizeof(Vector3));
     298    Vector3* texcoord = new Vector3[count];
    299299    for (int i = 0; i < count; ++i) {
    300         texcoord[i].set(0, 0, heights[i]);
     300        texcoord[i].set(0, 0, heights[i]);
    301301    }
    302302   
    … …  
    305305    glGenBuffers(1, &_vertexBufferObjectID);
    306306    glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObjectID);
    307     glBufferData(GL_ARRAY_BUFFER,
    308                  _vertexCount * sizeof( Vector3 ),
    309                  heightMap,
    310                  GL_STATIC_DRAW);
     307    glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof( Vector3 ), heightMap,
     308        GL_STATIC_DRAW);
    311309    glGenBuffers(1, &_textureBufferObjectID);
    312310    glBindBuffer(GL_ARRAY_BUFFER, _textureBufferObjectID);
    313     glBufferData(GL_ARRAY_BUFFER,
    314                  _vertexCount * sizeof(float) * 3,
    315                  texcoord,
    316                  GL_STATIC_DRAW);
     311    glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(float) * 3, texcoord,
     312        GL_STATIC_DRAW);
    317313    glBindBuffer(GL_ARRAY_BUFFER, 0);
    318314   
    319     free(texcoord);
     315    delete [] texcoord;
    320316   
    321317   
    … …  
    326322    //if (heightMap)
    327323    //{
    328     //  VertexBuffer* vertexBuffer = new VertexBuffer(VertexBuffer::POSITION3, xCount * yCount,
    329     //                                                                  sizeof(Vector3) * xCount * yCount, heightMap, false);
     324    //  VertexBuffer* vertexBuffer = new VertexBuffer(VertexBuffer::POSITION3, xCount * yCount,
     325    // sizeof(Vector3) * xCount * yCount, heightMap, false);
    330326    if (_indexBuffer) {
    331         free(_indexBuffer);
     327        free(_indexBuffer);
    332328    }
    333329    this->createIndexBuffer(xCount, yCount, _indexBuffer, _indexCount, heights);
    … …  
    347343   
    348344    for (int y = 0; y < yCount; ++y) {
    349         float yCoord;
    350 
    351         yCoord = startY + ((endY - startY) * y) / (yCount - 1);
    352         for (int x = 0; x < xCount; ++x) {
    353             float xCoord;
    354 
    355             xCoord = startX + ((endX - startX) * x) / (xCount - 1);
    356             dstDataPtr->set(xCoord, *srcDataPtr, yCoord);
    357 
    358             ++dstDataPtr;
    359             ++srcDataPtr;
    360         }
     345        float yCoord;
     346
     347        yCoord = startY + ((endY - startY) * y) / (yCount - 1);
     348        for (int x = 0; x < xCount; ++x) {
     349            float xCoord;
     350
     351            xCoord = startX + ((endX - startX) * x) / (xCount - 1);
     352            dstDataPtr->set(xCoord, *srcDataPtr, yCoord);
     353
     354            ++dstDataPtr;
     355            ++srcDataPtr;
     356        }
    361357    }
    362358    return vertices;

  • trunk/vizservers/nanovis/HeightMap.h

    r913 r927  
    3737    Vector3 _centerPoint;
    3838
    39     double _vmin;               // minimum (unscaled) value in data
    40     double _vmax;               // maximum (unscaled) value in data
    41 
    42 
     39    double _limits[3][2];
     40    double _vmin, _vmax;
    4341public :
    4442    /**
    … …  
    108106    double range_min(void);
    109107    double range_max(void);
     108    void set_limits(int axis, double min, double max);
     109    void get_limits(int axis, double *minPtr, double *maxPtr);
    110110};
    111111
    … …  
    138138}
    139139
     140inline void
     141HeightMap::set_limits(int axis, double min, double max)
     142{
     143    _limits[axis][0] = min;
     144    _limits[axis][1] = max;
     145}
     146
     147inline void
     148HeightMap::get_limits(int axis, double *minPtr, double *maxPtr)
     149{
     150    *minPtr = _limits[axis][0];
     151    *maxPtr = _limits[axis][1];
     152}
     153
    140154inline double
    141155HeightMap::range_min()

  • trunk/vizservers/nanovis/Volume.h

    r884 r927  
    5757    int n_components;
    5858
     59    double _limits[3][2];       // min/max for each axis
     60
    5961    double vmin;                // minimum (unscaled) value in data
    6062    double vmax;                // maximum (unscaled) value in data
    … …  
    113115    Vector3* get_location();
    114116   
    115         void set_isosurface(int iso);
    116         int get_isosurface() const;
     117    void set_isosurface(int iso);
     118    int get_isosurface() const;
    117119
    118120    double range_min() { return vmin; }
    … …  
    153155    void get_outline_color(float* rgb);
    154156   
    155    
     157    void set_limits(int axis, double min, double max);
     158    void get_limits(int axis, double *minPtr, double *maxPtr);
    156159    void set_label(int axis, const char* txt); // change the label displayed
    157160                                               // on an axis
    … …  
    180183}
    181184
    182 inline void Volume::enable_cutplane(int index){
     185inline void
     186Volume::enable_cutplane(int index)
     187{
    183188    //assert(index < plane.size());
    184189    plane[index].enabled = true;
    185190}
    186 inline
    187 void Volume::disable_cutplane(int index){
     191inline void
     192Volume::disable_cutplane(int index)
     193{
    188194    //assert(index < plane.size());
    189195    plane[index].enabled = false;
    190196}
    191197
    192 inline void Volume::move_cutplane(int index, float location){
     198inline void
     199Volume::move_cutplane(int index, float location)
     200{
    193201    //assert(index < plane.size());
    194202    plane[index].offset = location;
    195203}
    196204
    197 inline CutPlane* Volume::get_cutplane(int index){
     205inline CutPlane*
     206Volume::get_cutplane(int index)
     207{
    198208    //assert(index < plane.size());
    199209    return &plane[index];
    200210}
    201211
    202 inline int Volume::get_cutplane_count(){
     212inline int
     213Volume::get_cutplane_count()
     214{
    203215    return plane.size();
    204216}
    205217
    206 inline bool Volume::cutplane_is_enabled(int index){
     218inline bool
     219Volume::cutplane_is_enabled(int index)
     220{
    207221    //assert(index < plane.size());
    208222    return plane[index].enabled;
    209223}
    210224
    211 inline void Volume::set_n_slice(int n) {
     225inline void
     226Volume::set_n_slice(int n)
     227{
    212228    n_slice = n;
    213229}
    214 inline int Volume::get_n_slice() {
     230
     231inline int
     232Volume::get_n_slice()
     233{
    215234    return n_slice;
    216235}
    217236
    218 inline void Volume::set_size(float s) {
     237inline void
     238Volume::set_size(float s)
     239{
    219240    size = s;
    220241    aspect_ratio_width = s*tex->aspect_ratio_width;
    … …  
    223244}
    224245
    225 inline float Volume::get_specular() {
     246inline float
     247Volume::get_specular()
     248{
    226249    return specular;
    227250}
    228251
    229 inline float Volume::get_diffuse() {
     252inline float
     253Volume::get_diffuse()
     254{
    230255    return diffuse;
    231256}
    232257
    233 inline float Volume::get_opacity_scale() {
     258inline float
     259Volume::get_opacity_scale()
     260{
    234261    return opacity_scale;
    235262}
    236263
    237 inline void Volume::set_specular(float s) {
     264inline void
     265Volume::set_specular(float s)
     266{
    238267    specular = s;
    239268}
    240269
    241 inline void Volume::set_diffuse(float d) {
     270inline void
     271Volume::set_diffuse(float d)
     272{
    242273    diffuse = d;
    243274}
    244275
    245 inline void Volume::set_opacity_scale(float s) {
     276inline void
     277Volume::set_opacity_scale(float s)
     278{
    246279    opacity_scale = s;
    247280}
    248281
    249 inline void Volume::enable_data() {
     282inline void
     283Volume::enable_data()
     284{
    250285    data_enabled = true;
    251286}
    252287
    253 inline void Volume::disable_data() {
     288inline void
     289Volume::disable_data()
     290{
    254291    data_enabled = false;
    255292}
    256293
    257 inline bool Volume::data_is_enabled() {
     294inline bool
     295Volume::data_is_enabled()
     296{
    258297    return data_enabled;
    259298}
    260299
    261 inline void Volume::enable_outline() {
     300inline void
     301Volume::enable_outline()
     302{
    262303    outline_enabled = true;
    263304}
    264305
    265 inline void Volume::disable_outline() {
     306inline void
     307Volume::disable_outline()
     308{
    266309    outline_enabled = false;
    267310}
    268311
    269 inline bool Volume::outline_is_enabled() {
     312inline bool
     313Volume::outline_is_enabled()
     314{
    270315    return outline_enabled;
    271316}
    272317
    273 inline void Volume::set_outline_color(float *rgb) {
     318inline void
     319Volume::set_outline_color(float *rgb)
     320{
    274321    outline_color = Color(rgb[0],rgb[1],rgb[2]);
    275322}
    276323
    277 inline void Volume::get_outline_color(float *rgb) {
     324inline void
     325Volume::get_outline_color(float *rgb)
     326{
    278327    outline_color.GetRGB(rgb);
    279328}
    280329
    281 inline void Volume::set_label(int axis, const char* txt){
     330inline void
     331Volume::set_label(int axis, const char* txt)
     332{
    282333    label[axis] = txt;
    283334}
    284335
    285 inline int Volume::get_isosurface() const
    286 {
    287         return iso_surface;
    288 }
    289 
    290 inline void Volume::set_isosurface(int iso)
     336inline void
     337Volume::set_limits(int axis, double min, double max)
     338{
     339    _limits[axis][0] = min;
     340    _limits[axis][1] = max;
     341}
     342
     343inline void
     344Volume::get_limits(int axis, double *minPtr, double *maxPtr)
     345{
     346    *minPtr = _limits[axis][0];
     347    *maxPtr = _limits[axis][1];
     348}
     349
     350inline int
     351Volume::get_isosurface() const
     352{
     353    return iso_surface;
     354}
     355
     356inline void
     357Volume::set_isosurface(int iso)
    291358{
    292359    iso_surface = iso;

  • trunk/vizservers/nanovis/VolumeInterpolator.cpp

    r900 r927  
     1
    12#include "VolumeInterpolator.h"
    23#include "Volume.h"
    … …  
    1011#include "Trace.h"
    1112
    12 VolumeInterpolator::VolumeInterpolator()
    13 : _started(false), _volume(0), _numBytes(0), _interval(8.0), _dataCount(0), _n_components(0), _referenceOfVolume(0)
     13VolumeInterpolator::VolumeInterpolator() :
     14    _volume(0),
     15    _interval(8.0),
     16    _started(false),
     17    _numBytes(0),
     18    _dataCount(0),
     19    _n_components(0),
     20    _referenceOfVolume(0)
    1421{
     22    /*empty*/
    1523}
    1624
    1725void VolumeInterpolator::start()
    1826{
    19     if (_volumes.size() != 0)
    20     {
     27    if (_volumes.size() != 0) {
    2128        Trace("\tVolume Interpolation Started\n");
    22             _started = true;
    23     }
    24     else
    25     {
     29        _started = true;
     30    } else {
    2631        Trace("\tVolume Interpolation did not get started\n");
    2732        _started = false;
    … …  
    3742void VolumeInterpolator::stop()
    3843{
    39         _started = false;
     44    _started = false;
    4045}
    4146
    … …  
    4752    computeKeys(fraction, _volumes.size(), &interp, &key1, &key2);
    4853
    49     if (interp == 0.0f)
    50     {
     54    if (interp == 0.0f) {
    5155        memcpy(_volume->_data, _volumes[key1]->_data, _numBytes);
    5256        _volume->tex->update(_volume->_data);
    53     }
    54     else
    55     {
     57    } else {
    5658        float* data1 = _volumes[key1]->_data;
    5759        float* data2 = _volumes[key2]->_data;
    … …  
    5961
    6062        Vector3 normal1, normal2, normal;
    61         for (int i = 0; i < _dataCount; ++i)
    62         {
     63        for (unsigned int i = 0; i < _dataCount; ++i) {
    6364            *result = interp * (*data2 - *data1) + *data1;
    6465            normal1 = (*(Vector3*)(data1 + 1) - 0.5) * 2;
    … …  
    8081}
    8182
    82 void VolumeInterpolator::computeKeys(float fraction, int count, float* interp, int* key1, int* key2)
     83void
     84VolumeInterpolator::computeKeys(float fraction, int count, float* interp,
     85                                int* key1, int* key2)
    8386{
    84         int limit = (int) count - 1;
    85         if (fraction <= 0)
    86     {
    87             *key1 = *key2 = 0;
     87    int limit = (int) count - 1;
     88    if (fraction <= 0) {
     89        *key1 = *key2 = 0;
    8890        *interp = 0.0f;
    89     }
    90     else if (fraction >= 1.0f)
    91     {
    92             *key1 = *key2 = limit;
     91    } else if (fraction >= 1.0f) {
     92        *key1 = *key2 = limit;
    9393        *interp = 0.0f;
    94         }
    95     else
    96     {
     94    } else {
    9795        int n;
    9896        for (n = 0;n < limit; n++){
    99             if (fraction >= (n / (count - 1.0f)) && fraction < ((n+1)/(count-1.0f))) break;
     97            if (fraction >= (n / (count - 1.0f)) &&
     98                fraction < ((n+1)/(count-1.0f))) {
     99                break;
     100            }
    100101        }
    101 
     102       
    102103        Trace("n = %d count = %d\n", n, count);
    103104        if (n >= limit){
    104                 *key1 = *key2 = limit;
     105            *key1 = *key2 = limit;
    105106            *interp = 0.0f;
    106 
    107         }
    108         else {
    109                 *key1 = n;
     107           
     108        } else {
     109            *key1 = n;
    110110            *key2 = n+1;
    111                 *interp = (fraction - (n / (count -1.0f))) / ((n + 1) / (count - 1.0f) - n / (count - 1.0f));
     111            *interp = (fraction - (n / (count -1.0f))) / ((n + 1) / (count - 1.0f) - n / (count - 1.0f));
    112112            //*ret = inter * (keyValue[n + 1] - keyValue[n]) + keyValue[n];
    113113        }
    … …  
    115115}
    116116
    117 void VolumeInterpolator::clearAll()
     117void
     118VolumeInterpolator::clearAll()
    118119{
    119         _volumes.clear();
     120    _volumes.clear();
    120121
    121122    if (_volume) delete _volume;
    122123}
    123124
    124 void VolumeInterpolator::addVolume(Volume* volume, unsigned int volumeId)
     125void
     126VolumeInterpolator::addVolume(Volume* volume, unsigned int volumeId)
    125127{
    126     if (_volumes.size() != 0)
    127     {
    128         if (_volumes[0]->width != volume->width || _volumes[0]->height != volume->height ||   
    129             _volumes[0]->depth != volume->depth || _volumes[0]->n_components != volume->n_components)
    130         {
     128    if (_volumes.size() != 0) {
     129        if (_volumes[0]->width != volume->width ||
     130            _volumes[0]->height != volume->height ||   
     131            _volumes[0]->depth != volume->depth ||
     132            _volumes[0]->n_components != volume->n_components) {
    131133            printf("The volume should be the same width, height, number of components\n");
    132134            return;
    133135        }
    134 
    135     }
    136     else
    137     {
     136       
     137    } else {
    138138        _dataCount = volume->width * volume->height * volume->depth;
    139139        _n_components = volume->n_components;
    140140        _numBytes = _dataCount * _n_components * sizeof(float);
    141         _volume = new Volume(volume->location.x, volume->location.y, volume->location.z,
    142                         volume->width, volume->height, volume->depth,
    143                         volume->size,
    144                         volume->n_components,
    145                         volume->_data,
    146                         volume->vmin,
    147                         volume->vmax, volume->nonzero_min);
     141        _volume = new Volume(volume->location.x,
     142                             volume->location.y,
     143                             volume->location.z,
     144                             volume->width, volume->height, volume->depth,
     145                             volume->size,
     146                             volume->n_components,
     147                             volume->_data,
     148                             volume->vmin,
     149                             volume->vmax, volume->nonzero_min);
    148150        _referenceOfVolume = volumeId;
    149151        _volume->set_n_slice(256-1);
    … …  
    157159        _volume->set_opacity_scale(volume->get_opacity_scale());
    158160        _volume->set_isosurface(0);
    159 
    160         Trace("VOL : location %f %f %f\n\tid : %d\n", _volume->location.x, _volume->location.y, _volume->location.z,
    161                                         volumeId);
     161       
     162        Trace("VOL : location %f %f %f\n\tid : %d\n", _volume->location.x,
     163                _volume->location.y, _volume->location.z, volumeId);
    162164    }
    163165
    164         _volumes.push_back(volume);
    165 
     166    _volumes.push_back(volume);
    166167    Trace("a Volume[%d] is added to VolumeInterpolator\n", volumeId);
    167168}

  • trunk/vizservers/nanovis/VolumeInterpolator.h

    r900 r927  
    99    Volume* _volume;
    1010
    11         std::vector<Volume*> _volumes;
     11    std::vector<Volume*> _volumes;
    1212
    1313    double _interval;
    14         bool _started;
     14    bool _started;
    1515    unsigned int _numBytes;
    1616    unsigned int _dataCount;
    … …  
    2020
    2121public :
    22         VolumeInterpolator();
    23         void addVolume(Volume* vol, unsigned int volumeId);
    24         void clearAll();
    25 
    26         void start();
    27         Volume* update(float fraction);
    28         void stop();
     22    VolumeInterpolator();
     23    void addVolume(Volume* vol, unsigned int volumeId);
     24    void clearAll();
     25   
     26    void start();
     27    Volume* update(float fraction);
     28    void stop();
    2929    void computeKeys(float fraction, int count, float* interp, int* key1, int* key2);
    3030    bool is_started() const;

  • trunk/vizservers/nanovis/VolumeRenderer.cpp

    r923 r927  
    8484VolumeRenderer::shade_volume(Volume* _vol, TransferFunction* _tf)
    8585{
    86   for (int i=0; i < volume.size(); i++) {
    87     if (volume[i] == _vol) {
    88       tf[i] = _tf;
    89     }
    90   }
     86    for (unsigned int i=0; i < volume.size(); i++) {
     87        if (volume[i] == _vol) {
     88            tf[i] = _tf;
     89        }
     90    }
    9191}
    9292
    … …  
    9494VolumeRenderer::get_volume_shading(Volume* _vol)
    9595{
    96   for (int i=0; i < volume.size(); i++) {
    97     if (volume[i] == _vol) {
    98       return tf[i];
    99     }
    100   }
    101   return NULL;
     96    for (unsigned int i=0; i < volume.size(); i++) {
     97        if (volume[i] == _vol) {
     98            return tf[i];
     99        }
     100    }
     101    return NULL;
    102102}
    103103

  • trunk/vizservers/nanovis/dxReader.cpp

    r911 r927  
    1 
     1 
    22/*
    33 * ----------------------------------------------------------------------
    … …  
    55 *
    66 *  dxReader.cpp
    7  *      This module contains openDX readers for 2D and 3D volumes.
     7 *      This module contains openDX readers for 2D and 3D volumes.
    88 *
    99 * ======================================================================
    … …  
    5151    int ngen = 0, sindex = 0;
    5252    for (sindex = 0; sindex <size; ++sindex) {
    53         data[ngen++] = scalar[sindex];
    54         data[ngen++] = g[sindex].x;
    55         data[ngen++] = g[sindex].y;
    56         data[ngen++] = g[sindex].z;
     53        data[ngen++] = scalar[sindex];
     54        data[ngen++] = g[sindex].x;
     55        data[ngen++] = g[sindex].y;
     56        data[ngen++] = g[sindex].z;
    5757    }
    5858    return data;
    … …  
    6666        for (int i = 0; i < count; ++i) {
    6767            fdata[i] = fdata[i] / v;
    68         }
     68        }
    6969    }
    7070}
    … …  
    7272static float*
    7373computeGradient(float* fdata, int width, int height, int depth,
    74                 float min, float max)
     74                float min, float max)
    7575{
    7676    float* gradients = (float *)malloc(width * height * depth * 3 *
    77                                        sizeof(float));
     77                                       sizeof(float));
    7878    float* tempGradients = (float *)malloc(width * height * depth * 3 *
    79                                            sizeof(float));
     79                                           sizeof(float));
    8080    int sizes[3] = { width, height, depth };
    8181    computeGradients(tempGradients, fdata, sizes, DATRAW_FLOAT);
    … …  
    9797    char line[128], type[128], *start;
    9898
    99     dx = dy = dz = 0.0;         // Suppress compiler warning.
     99    dx = dy = dz = 0.0;         // Suppress compiler warning.
    100100    while (!fin.eof()) {
    101101        fin.getline(line, sizeof(line) - 1);
    102         if (fin.fail()) {
    103             //return result.error("error in data stream");
    104             return;
    105         }
     102        if (fin.fail()) {
     103            //return result.error("error in data stream");
     104            return;
     105        }
    106106        for (start=&line[0]; *start == ' ' || *start == '\t'; start++)
    107107            ;  // skip leading blanks
    … …  
    115115                // found one of the delta lines
    116116                if (ddx != 0.0) {
    117                     dx = ddx;
    118                 } else if (ddy != 0.0) {
    119                     dy = ddy;
    120                 } else if (ddz != 0.0) {
    121                     dz = ddz;
    122                 }
     117                    dx = ddx;
     118                } else if (ddy != 0.0) {
     119                    dy = ddy;
     120                } else if (ddz != 0.0) {
     121                    dz = ddz;
     122                }
    123123            } else if (sscanf(start, "object %d class array type %s shape 3 rank 1 items %d data follows", &dummy, type, &npts) == 3) {
    124124                if (npts != nx*ny*nz) {
    … …  
    185185#ifndef NV40
    186186        // must be an even power of 2 for older cards
    187             nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    188             ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    189             nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
     187        nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
     188        ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
     189        nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    190190#endif
    191191
    … …  
    211211                    vz = zfield.value(xval,yval,zval);
    212212
    213                     double vm = sqrt(vx*vx + vy*vy + vz*vz);
    214 
    215                     if (vm < vmin) { vmin = vm; }
    216                     if (vm > vmax) { vmax = vm; }
    217                     if (vm != 0.0f && vm < nzero_min)
    218                     {
     213                    double vm;
     214                    vm = sqrt(vx*vx + vy*vy + vz*vz);
     215                    if (vm < vmin) {
     216                        vmin = vm;
     217                    } else if (vm > vmax) {
     218                        vmax = vm;
     219                    }
     220                    if ((vm != 0.0f) && (vm < nzero_min)) {
    219221                        nzero_min = vm;
    220222                    }
    221 
    222223                    data[ngen++] = vx;
    223224                    data[ngen++] = vy;
    … …  
    233234            data[ngen] = (data[ngen]/(2.0*vmax) + 0.5);
    234235        }
    235         NanoVis::load_volume(index, nx, ny, nz, 3, data, vmin, vmax, nzero_min);
     236        Volume *volPtr;
     237        volPtr = NanoVis::load_volume(index, nx, ny, nz, 3, data, vmin, vmax,
     238                nzero_min);
     239        volPtr->set_limits(0, x0, x0 + (nx * ddx));
     240        volPtr->set_limits(1, y0, y0 + (ny * ddy));
     241        volPtr->set_limits(2, z0, z0 + (nz * ddz));
    236242        delete [] data;
    237243    } else {
    … …  
    254260
    255261    int isrect = 1;
    256     dx = dy = dz = 0.0;         // Suppress compiler warning.
     262    dx = dy = dz = 0.0;         // Suppress compiler warning.
    257263    do {
    258264        fin.getline(line,sizeof(line)-1);
    … …  
    265271                // found grid size
    266272                isrect = 1;
    267             }
    268             else if (sscanf(start, "object %d class array type float rank 1 shape 3 items %d data follows", &dummy, &nxy) == 2) {
     273            } else if (sscanf(start, "object %d class array type float rank 1 shape 3 items %d data follows", &dummy, &nxy) == 2) {
    269274                isrect = 0;
    270275                double xx, yy, zz;
    … …  
    280285                result.error(mesg);
    281286                return result;
     287
     288                char fpts[128];
     289                sprintf(fpts, "/tmp/tmppts%d", getpid());
     290                char fcells[128];
     291                sprintf(fcells, "/tmp/tmpcells%d", getpid());
     292
     293                std::ofstream ftmp(fpts);
     294                // save corners of bounding box first, to work around meshing
     295                // problems in voronoi utility
     296                ftmp << xymesh.rangeMin(Rappture::xaxis) << " "
     297                     << xymesh.rangeMin(Rappture::yaxis) << std::endl;
     298                ftmp << xymesh.rangeMax(Rappture::xaxis) << " "
     299                     << xymesh.rangeMin(Rappture::yaxis) << std::endl;
     300                ftmp << xymesh.rangeMax(Rappture::xaxis) << " "
     301                     << xymesh.rangeMax(Rappture::yaxis) << std::endl;
     302                ftmp << xymesh.rangeMin(Rappture::xaxis) << " "
     303                     << xymesh.rangeMax(Rappture::yaxis) << std::endl;
     304                for (int i=0; i < nxy; i++) {
     305                    ftmp << xymesh.atNode(i).x() << " " << xymesh.atNode(i).y() << std::endl;
     306               
     307                }
     308                ftmp.close();
     309
     310                char cmdstr[512];
     311                sprintf(cmdstr, "voronoi -t < %s > %s", fpts, fcells);
     312                if (system(cmdstr) == 0) {
     313                    int cx, cy, cz;
     314                    std::ifstream ftri(fcells);
     315                    while (!ftri.eof()) {
     316                        ftri.getline(line,sizeof(line)-1);
     317                        if (sscanf(line, "%d %d %d", &cx, &cy, &cz) == 3) {
     318                            if (cx >= 4 && cy >= 4 && cz >= 4) {
     319                                // skip first 4 boundary points
     320                                xymesh.addCell(cx-4, cy-4, cz-4);
     321                            }
     322                        }
     323                    }
     324                    ftri.close();
     325                } else {
     326                    return result.error("triangularization failed");
     327                }
     328
     329                sprintf(cmdstr, "rm -f %s %s", fpts, fcells);
     330                system(cmdstr);
     331            } else if (sscanf(start, "object %d class regulararray count %d", &dummy, &nz) == 2) {
     332                // found z-grid
     333            } else if (sscanf(start, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
     334                // found origin
     335            } else if (sscanf(start, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
     336                int count = 0;
     337                // found one of the delta lines
     338                if (ddx != 0.0) {
     339                    dx = ddx;
     340                    count++;
     341                }
     342                if (ddy != 0.0) {
     343                    dy = ddy;
     344                    count++;
     345                }
     346                if (ddz != 0.0) {
     347                    dz = ddz;
     348                    count++;
     349                }
     350                if (count > 1) {
     351                    return result.error(
     352                        "don't know how to handle multiple non-zero delta values");
     353                }
     354            } else if (sscanf(start, "object %d class array type %s rank 0 items %d data follows", &dummy, type, &npts) == 3) {
     355                if (isrect && (npts != nx*ny*nz)) {
     356                    char mesg[256];
     357                    sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, npts);
     358                    return result.error(mesg);
     359                } else if (!isrect && (npts != nxy*nz)) {
     360                    char mesg[256];
     361                    sprintf(mesg,"inconsistent data: expected %d points but found %d points", nxy*nz, npts);
     362                    return result.error(mesg);
     363                }
     364                break;
     365            } else if (sscanf(start, "object %d class array type %s rank 0 times %d data follows", &dummy, type, &npts) == 3) {
     366                if (npts != nx*ny*nz) {
     367                    char mesg[256];
     368                    sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, npts);
     369                    return result.error(mesg);
     370                }
     371                break;
     372            }
     373        }
     374    } while (!fin.eof());
     375
     376    // read data points
     377    if (!fin.eof()) {
     378        if (isrect) {
     379            double dval[6];
     380            int nread = 0;
     381            int ix = 0;
     382            int iy = 0;
     383            int iz = 0;
     384            float* data = new float[nx *  ny *  nz * 4];
     385            memset(data, 0, nx*ny*nz*4);
     386            double vmin = 1e21;
     387            double nzero_min = 1e21;
     388            double vmax = -1e21;
     389
     390
     391            while (!fin.eof() && nread < npts) {
     392                fin.getline(line,sizeof(line)-1);
     393                int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
     394
     395                for (int p=0; p < n; p++) {
     396                    int nindex = (iz*nx*ny + iy*nx + ix) * 4;
     397                    data[nindex] = dval[p];
     398
     399                    if (dval[p] < vmin) {
     400                        vmin = dval[p];
     401                    } else if (dval[p] > vmax) {
     402                        vmax = dval[p];
     403                    }
     404                    if (dval[p] != 0.0f && dval[p] < nzero_min) {
     405                        nzero_min = dval[p];
     406                    }
     407
     408                    nread++;
     409                    if (++iz >= nz) {
     410                        iz = 0;
     411                        if (++iy >= ny) {
     412                            iy = 0;
     413                            ++ix;
     414                        }
     415                    }
     416                }
     417            }
     418
     419            // make sure that we read all of the expected points
     420            if (nread != nx*ny*nz) {
     421                char mesg[256];
     422                sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, nread);
     423                result.error(mesg);
     424                return result;
     425            }
     426
     427            double dv = vmax - vmin;
     428            int count = nx*ny*nz;
     429            int ngen = 0;
     430            double v;
     431            printf("test2\n");
     432            fflush(stdout);
     433            if (dv == 0.0) {
     434                dv = 1.0;
     435            }
     436            for (int i = 0; i < count; ++i) {
     437                v = data[ngen];
     438                // scale all values [0-1], -1 => out of bounds
     439                v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
     440                data[ngen] = v;
     441                ngen += 4;
     442            }
     443            // Compute the gradient of this data.  BE CAREFUL: center
     444            // calculation on each node to avoid skew in either direction.
     445            ngen = 0;
     446            for (int iz=0; iz < nz; iz++) {
     447                for (int iy=0; iy < ny; iy++) {
     448                    for (int ix=0; ix < nx; ix++) {
     449                        // gradient in x-direction
     450                        double valm1 = (ix == 0) ? 0.0 : data[ngen - 4];
     451                        double valp1 = (ix == nx-1) ? 0.0 : data[ngen + 4];
     452                        if (valm1 < 0 || valp1 < 0) {
     453                            data[ngen+1] = 0.0;
     454                        } else {
     455                            data[ngen+1] = valp1-valm1; // assume dx=1
     456                            //data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
     457                        }
     458
     459                        // gradient in y-direction
     460                        valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
     461                        valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
     462                        if (valm1 < 0 || valp1 < 0) {
     463                            data[ngen+2] = 0.0;
     464                        } else {
     465                            data[ngen+2] = valp1-valm1; // assume dx=1
     466                            //data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dy=1
     467                        }
     468
     469                        // gradient in z-direction
     470                        valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
     471                        valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
     472                        if (valm1 < 0 || valp1 < 0) {
     473                            data[ngen+3] = 0.0;
     474                        } else {
     475                            data[ngen+3] = valp1-valm1; // assume dx=1
     476                            //data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
     477                        }
     478
     479                        ngen += 4;
     480                    }
     481                }
     482            }
     483
     484            dx = nx;
     485            dy = ny;
     486            dz = nz;
     487            Volume *volPtr;
     488            volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
     489                                          vmin, vmax, nzero_min);
     490            volPtr->set_limits(NanoVis::X, x0, x0 + (nx * ddx));
     491            volPtr->set_limits(NanoVis::Y, y0, y0 + (ny * ddy));
     492            volPtr->set_limits(NanoVis::Z, z0, z0 + (nz * ddz));
     493            delete [] data;
     494
     495        } else {
     496            Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
     497            Rappture::FieldPrism3D field(xymesh, zgrid);
     498
     499            double dval;
     500            int nread = 0;
     501            int ixy = 0;
     502            int iz = 0;
     503            while (!fin.eof() && nread < npts) {
     504                fin >> dval;
     505                if (fin.fail()) {
     506                    char mesg[256];
     507                    sprintf(mesg,"after %d of %d points: can't read number",
     508                            nread, npts);
     509                    return result.error(mesg);
     510                } else {
     511                    int nid = nxy*iz + ixy;
     512                    field.define(nid, dval);
     513
     514                    nread++;
     515                    if (++iz >= nz) {
     516                        iz = 0;
     517                        ixy++;
     518                    }
     519                }
     520            }
     521
     522            // make sure that we read all of the expected points
     523            if (nread != nxy*nz) {
     524                char mesg[256];
     525                sprintf(mesg,"inconsistent data: expected %d points but found %d points", nxy*nz, nread);
     526                return result.error(mesg);
     527            }
     528
     529            // figure out a good mesh spacing
     530            int nsample = 30;
     531            x0 = field.rangeMin(Rappture::xaxis);
     532            dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
     533            y0 = field.rangeMin(Rappture::yaxis);
     534            dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
     535            z0 = field.rangeMin(Rappture::zaxis);
     536            dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
     537            double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
     538
     539            nx = (int)ceil(dx/dmin);
     540            ny = (int)ceil(dy/dmin);
     541            nz = (int)ceil(dz/dmin);
     542#ifndef NV40
     543            // must be an even power of 2 for older cards
     544            nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
     545            ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
     546            nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
     547#endif
     548            float *data = new float[4*nx*ny*nz];
     549
     550            double vmin = field.valueMin();
     551            double dv = field.valueMax() - field.valueMin();
     552            if (dv == 0.0) {
     553                dv = 1.0;
     554            }
     555            // generate the uniformly sampled data that we need for a volume
     556            int ngen = 0;
     557            double nzero_min = 0.0;
     558            for (iz=0; iz < nz; iz++) {
     559                double zval = z0 + iz*dmin;
     560                for (int iy=0; iy < ny; iy++) {
     561                    double yval = y0 + iy*dmin;
     562                    for (int ix=0; ix < nx; ix++) {
     563                        double xval = x0 + ix*dmin;
     564                        double v = field.value(xval,yval,zval);
     565
     566                        if (v != 0.0f && v < nzero_min)
     567                            {
     568                                nzero_min = v;
     569                            }
     570                        // scale all values [0-1], -1 => out of bounds
     571                        v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
     572                        data[ngen] = v;
     573
     574                        ngen += 4;
     575                    }
     576                }
     577            }
     578
     579            // Compute the gradient of this data.  BE CAREFUL: center
     580            // calculation on each node to avoid skew in either direction.
     581            ngen = 0;
     582            for (int iz=0; iz < nz; iz++) {
     583                for (int iy=0; iy < ny; iy++) {
     584                    for (int ix=0; ix < nx; ix++) {
     585                        // gradient in x-direction
     586                        double valm1 = (ix == 0) ? 0.0 : data[ngen-4];
     587                        double valp1 = (ix == nx-1) ? 0.0 : data[ngen+4];
     588                        if (valm1 < 0 || valp1 < 0) {
     589                            data[ngen+1] = 0.0;
     590                        } else {
     591                            //data[ngen+1] = valp1-valm1; // assume dx=1
     592                            data[ngen+1] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
     593                        }
     594
     595                        // gradient in y-direction
     596                        valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
     597                        valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
     598                        if (valm1 < 0 || valp1 < 0) {
     599                            data[ngen+2] = 0.0;
     600                        } else {
     601                            //data[ngen+2] = valp1-valm1; // assume dy=1
     602                            data[ngen+2] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
     603                        }
     604
     605                        // gradient in z-direction
     606                        valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
     607                        valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
     608                        if (valm1 < 0 || valp1 < 0) {
     609                            data[ngen+3] = 0.0;
     610                        } else {
     611                            //data[ngen+3] = valp1-valm1; // assume dz=1
     612                            data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
     613                        }
     614
     615                        ngen += 4;
     616                    }
     617                }
     618            }
     619
     620            Volume *volPtr;
     621            volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
     622                field.valueMin(), field.valueMax(), nzero_min);
     623            volPtr->set_limits(0, field.rangeMin(Rappture::xaxis),
     624                               field.rangeMax(Rappture::xaxis));
     625            volPtr->set_limits(1, field.rangeMin(Rappture::yaxis),
     626                               field.rangeMax(Rappture::yaxis));
     627            volPtr->set_limits(2, field.rangeMin(Rappture::zaxis),
     628                               field.rangeMax(Rappture::zaxis));
     629            delete [] data;
     630        }
     631    } else {
     632        return result.error("data not found in stream");
     633    }
     634
     635    //
     636    // Center this new volume on the origin.
     637    //
     638    float dx0 = -0.5;
     639    float dy0 = -0.5*dy/dx;
     640    float dz0 = -0.5*dz/dx;
     641    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
     642
     643    return result;
     644}
     645
     646Rappture::Outcome
     647load_volume_stream(int index, std::iostream& fin)
     648{
     649    Rappture::Outcome result;
     650
     651    Rappture::MeshTri2D xymesh;
     652    int dummy, nx, ny, nz, nxy, npts;
     653    double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
     654    char line[128], type[128], *start;
     655
     656    int isrect = 1;
     657
     658    dx = dy = dz = 0.0;         // Suppress compiler warning.
     659    while (!fin.eof()) {
     660        fin.getline(line, sizeof(line) - 1);
     661        if (fin.fail()) {
     662            return result.error("error in data stream");
     663        }
     664        for (start=line; *start == ' ' || *start == '\t'; start++)
     665            ;  // skip leading blanks
     666
     667        if (*start != '#') {  // skip comment lines
     668            if (sscanf(start, "object %d class gridpositions counts %d %d %d", &dummy, &nx, &ny, &nz) == 4) {
     669                // found grid size
     670                isrect = 1;
     671            } else if (sscanf(start, "object %d class array type float rank 1 shape 3 items %d data follows", &dummy, &nxy) == 2) {
     672                isrect = 0;
     673
     674                double xx, yy, zz;
     675                for (int i=0; i < nxy; i++) {
     676                    fin.getline(line,sizeof(line)-1);
     677                    if (sscanf(line, "%lg %lg %lg", &xx, &yy, &zz) == 3) {
     678                        xymesh.addNode( Rappture::Node2D(xx,yy) );
     679                    }
     680                }
    282681
    283682                char fpts[128];
    … …  
    353752            }
    354753        }
    355     } while (!fin.eof());
     754    }
    356755
    357756    // read data points
    358757    if (!fin.eof()) {
    359758        if (isrect) {
     759            Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
     760            Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
     761            Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
     762            Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
     763
    360764            double dval[6];
    361765            int nread = 0;
    … …  
    363767            int iy = 0;
    364768            int iz = 0;
    365             float* data = new float[nx *  ny *  nz * 4];
    366             memset(data, 0, nx*ny*nz*4);
    367             double vmin = 1e21;
    368             double nzero_min = 1e21;
    369             double vmax = -1e21;
    370 
    371 
    372769            while (!fin.eof() && nread < npts) {
    373770                fin.getline(line,sizeof(line)-1);
     771                if (fin.fail()) {
     772                    return result.error("error reading data points");
     773                }
    374774                int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
    375775
    376776                for (int p=0; p < n; p++) {
    377                     int nindex = (iz*nx*ny + iy*nx + ix) * 4;
    378                     data[nindex] = dval[p];
    379 
    380                     if (dval[p] < vmin) vmin = dval[p];
    381                     if (dval[p] > vmax) vmax = dval[p];
    382                     if (dval[p] != 0.0f && dval[p] < nzero_min) {
    383                          nzero_min = dval[p];
    384                     }
    385 
     777                    int nindex = iz*nx*ny + iy*nx + ix;
     778                    field.define(nindex, dval[p]);
    386779                    nread++;
    387780                    if (++iz >= nz) {
    … …  
    403796            }
    404797
    405             double dv = vmax - vmin;
    406             int count = nx*ny*nz;
     798            // figure out a good mesh spacing
     799            int nsample = 30;
     800            dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
     801            dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
     802            dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
     803            double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
     804
     805            nx = (int)ceil(dx/dmin);
     806            ny = (int)ceil(dy/dmin);
     807            nz = (int)ceil(dz/dmin);
     808
     809#ifndef NV40
     810            // must be an even power of 2 for older cards
     811            nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
     812            ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
     813            nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
     814#endif
     815
     816            float *cdata = new float[nx*ny*nz];
    407817            int ngen = 0;
    408             double v;
    409             printf("test2\n");
    410                         fflush(stdout);
    411             if (dv == 0.0) { dv = 1.0; }
    412             for (int i = 0; i < count; ++i)
    413             {
    414                 v = data[ngen];
    415                 // scale all values [0-1], -1 => out of bounds
    416                 v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
    417                 data[ngen] = v;
    418                 ngen += 4;
    419             }
     818            double nzero_min = 0.0;
     819            for (int iz=0; iz < nz; iz++) {
     820                double zval = z0 + iz*dmin;
     821                for (int iy=0; iy < ny; iy++) {
     822                    double yval = y0 + iy*dmin;
     823                    for (int ix=0; ix < nx; ix++) {
     824                        double xval = x0 + ix*dmin;
     825                        double v = field.value(xval,yval,zval);
     826
     827                        if (v != 0.0f && v < nzero_min) {
     828                            nzero_min = v;
     829                        }
     830
     831                        // scale all values [0-1], -1 => out of bounds
     832                        v = (isnan(v)) ? -1.0 : v;
     833
     834                        cdata[ngen] = v;
     835                        ++ngen;
     836                    }
     837                }
     838            }
     839
     840            float* data = computeGradient(cdata, nx, ny, nz, field.valueMin(),
     841                                          field.valueMax());
    420842
    421843            // Compute the gradient of this data.  BE CAREFUL: center
    422             // calculation on each node to avoid skew in either direction.
    423             ngen = 0;
    424             for (int iz=0; iz < nz; iz++) {
    425                 for (int iy=0; iy < ny; iy++) {
    426                     for (int ix=0; ix < nx; ix++) {
    427                         // gradient in x-direction
    428                         double valm1 = (ix == 0) ? 0.0 : data[ngen - 4];
    429                         double valp1 = (ix == nx-1) ? 0.0 : data[ngen + 4];
    430                         if (valm1 < 0 || valp1 < 0) {
    431                             data[ngen+1] = 0.0;
    432                         } else {
    433                             data[ngen+1] = valp1-valm1; // assume dx=1
    434                             //data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
    435                         }
    436 
    437                         // gradient in y-direction
    438                         valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
    439                         valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
    440                         if (valm1 < 0 || valp1 < 0) {
    441                             data[ngen+2] = 0.0;
    442                         } else {
    443                             data[ngen+2] = valp1-valm1; // assume dx=1
    444                             //data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dy=1
    445                         }
    446 
    447                         // gradient in z-direction
    448                         valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
    449                         valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
    450                         if (valm1 < 0 || valp1 < 0) {
    451                             data[ngen+3] = 0.0;
    452                         } else {
    453                             data[ngen+3] = valp1-valm1; // assume dx=1
    454                             //data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
    455                         }
    456 
    457                         ngen += 4;
    458                     }
    459                 }
    460             }
    461 
    462             dx = nx;
    463             dy = ny;
    464             dz = nz;
    465             NanoVis::load_volume(index, nx, ny, nz, 4, data,
    466                 vmin, vmax, nzero_min);
    467 
     844            /*
     845              float *data = new float[4*nx*ny*nz];
     846
     847              double vmin = field.valueMin();
     848              double dv = field.valueMax() - field.valueMin();
     849              if (dv == 0.0) { dv = 1.0; }
     850
     851              // generate the uniformly sampled data that we need for a volume
     852              int ngen = 0;
     853              double nzero_min = 0.0;
     854              for (int iz=0; iz < nz; iz++) {
     855              double zval = z0 + iz*dmin;
     856              for (int iy=0; iy < ny; iy++) {
     857              double yval = y0 + iy*dmin;
     858              for (int ix=0; ix < nx; ix++) {
     859              double xval = x0 + ix*dmin;
     860              double v = field.value(xval,yval,zval);
     861
     862              if (v != 0.0f && v < nzero_min)
     863              {
     864              nzero_min = v;
     865              }
     866
     867              // scale all values [0-1], -1 => out of bounds
     868              v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
     869
     870              data[ngen] = v;
     871              ngen += 4;
     872              }
     873              }
     874              }
     875              // Compute the gradient of this data.  BE CAREFUL: center
     876              // calculation on each node to avoid skew in either direction.
     877              ngen = 0;
     878              for (int iz=0; iz < nz; iz++) {
     879              for (int iy=0; iy < ny; iy++) {
     880              for (int ix=0; ix < nx; ix++) {
     881              // gradient in x-direction
     882              double valm1 = (ix == 0) ? 0.0 : data[ngen-4];
     883              double valp1 = (ix == nx-1) ? 0.0 : data[ngen+4];
     884              if (valm1 < 0 || valp1 < 0) {
     885              data[ngen+1] = 0.0;
     886              } else {
     887              data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
     888              }
     889
     890              // gradient in y-direction
     891              valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
     892              valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
     893              if (valm1 < 0 || valp1 < 0) {
     894              data[ngen+2] = 0.0;
     895              } else {
     896              //data[ngen+2] = valp1-valm1; // assume dy=1
     897              data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
     898              }
     899
     900              // gradient in z-direction
     901              valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
     902              valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
     903              if (valm1 < 0 || valp1 < 0) {
     904              data[ngen+3] = 0.0;
     905              } else {
     906              //data[ngen+3] = valp1-valm1; // assume dz=1
     907              data[ngen+3] = ((valp1-valm1) + 1) *  0.5; // assume dz=1
     908              }
     909
     910              ngen += 4;
     911              }
     912              }
     913              }
     914            */
     915
     916            Volume *volPtr;
     917            volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
     918                field.valueMin(), field.valueMax(), nzero_min);
     919            volPtr->set_limits(0, field.rangeMin(Rappture::xaxis),
     920                               field.rangeMax(Rappture::xaxis));
     921            volPtr->set_limits(1, field.rangeMin(Rappture::yaxis),
     922                               field.rangeMax(Rappture::yaxis));
     923            volPtr->set_limits(2, field.rangeMin(Rappture::zaxis),
     924                               field.rangeMax(Rappture::zaxis));
     925            // TBD..
     926            // POINTSET
     927            /*
     928              PointSet* pset = new PointSet();
     929              pset->initialize(volume[index], (float*) data);
     930              pset->setVisible(true);
     931              NanoVis::pointSet.push_back(pset);
     932              updateColor(pset);
     933              NanoVis::volume[index]->pointsetIndex = NanoVis::pointSet.size() - 1;
     934            */
     935 
    468936            delete [] data;
    469937
    … …  
    477945            int iz = 0;
    478946            while (!fin.eof() && nread < npts) {
    479                 fin >> dval;
     947                fin >> dval;
    480948                if (fin.fail()) {
    481                     char mesg[256];
    482                     sprintf(mesg,"after %d of %d points: can't read number",
    483                             nread, npts);
    484                     return result.error(mesg);
    485                 } else {
     949                    char mesg[256];
     950                    sprintf(mesg,"after %d of %d points: can't read number",
     951                            nread, npts);
     952                    return result.error(mesg);
     953                } else {
    486954                    int nid = nxy*iz + ixy;
    487955                    field.define(nid, dval);
    … …  
    517985#ifndef NV40
    518986            // must be an even power of 2 for older cards
    519                 nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    520                 ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    521                 nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
     987            nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
     988            ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
     989            nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    522990#endif
    523991            float *data = new float[4*nx*ny*nz];
    … …  
    5391007
    5401008                        if (v != 0.0f && v < nzero_min)
    541                         {
    542                             nzero_min = v;
    543                         }
    544                         // scale all values [0-1], -1 => out of bounds
    545                         v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
    546                         data[ngen] = v;
    547 
    548                         ngen += 4;
    549                     }
    550                 }
    551             }
    552 
    553             // Compute the gradient of this data.  BE CAREFUL: center
    554             // calculation on each node to avoid skew in either direction.
    555             ngen = 0;
    556             for (int iz=0; iz < nz; iz++) {
    557                 for (int iy=0; iy < ny; iy++) {
    558                     for (int ix=0; ix < nx; ix++) {
    559                         // gradient in x-direction
    560                         double valm1 = (ix == 0) ? 0.0 : data[ngen-4];
    561                         double valp1 = (ix == nx-1) ? 0.0 : data[ngen+4];
    562                         if (valm1 < 0 || valp1 < 0) {
    563                             data[ngen+1] = 0.0;
    564                         } else {
    565                             //data[ngen+1] = valp1-valm1; // assume dx=1
    566                             data[ngen+1] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
    567                         }
    568 
    569                         // gradient in y-direction
    570                         valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
    571                         valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
    572                         if (valm1 < 0 || valp1 < 0) {
    573                             data[ngen+2] = 0.0;
    574                         } else {
    575                             //data[ngen+2] = valp1-valm1; // assume dy=1
    576                             data[ngen+2] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
    577                         }
    578 
    579                         // gradient in z-direction
    580                         valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
    581                         valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
    582                         if (valm1 < 0 || valp1 < 0) {
    583                             data[ngen+3] = 0.0;
    584                         } else {
    585                             //data[ngen+3] = valp1-valm1; // assume dz=1
    586                             data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1
    587                         }
    588 
    589                         ngen += 4;
    590                     }
    591                 }
    592             }
    593 
    594             NanoVis::load_volume(index, nx, ny, nz, 4, data,
    595                 field.valueMin(), field.valueMax(), nzero_min);
    596 
    597             delete [] data;
    598         }
    599     } else {
    600         return result.error("data not found in stream");
    601     }
    602 
    603     //
    604     // Center this new volume on the origin.
    605     //
    606     float dx0 = -0.5;
    607     float dy0 = -0.5*dy/dx;
    608     float dz0 = -0.5*dz/dx;
    609     NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
    610 
    611     return result;
    612 }
    613 
    614 Rappture::Outcome
    615 load_volume_stream(int index, std::iostream& fin)
    616 {
    617     Rappture::Outcome result;
    618 
    619     Rappture::MeshTri2D xymesh;
    620     int dummy, nx, ny, nz, nxy, npts;
    621     double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
    622     char line[128], type[128], *start;
    623 
    624     int isrect = 1;
    625 
    626     dx = dy = dz = 0.0;         // Suppress compiler warning.
    627     while (!fin.eof()) {
    628         fin.getline(line, sizeof(line) - 1);
    629         if (fin.fail()) {
    630             return result.error("error in data stream");
    631         }
    632         for (start=line; *start == ' ' || *start == '\t'; start++)
    633             ;  // skip leading blanks
    634 
    635         if (*start != '#') {  // skip comment lines
    636             if (sscanf(start, "object %d class gridpositions counts %d %d %d", &dummy, &nx, &ny, &nz) == 4) {
    637                 // found grid size
    638                 isrect = 1;
    639             } else if (sscanf(start, "object %d class array type float rank 1 shape 3 items %d data follows", &dummy, &nxy) == 2) {
    640                 isrect = 0;
    641 
    642                 double xx, yy, zz;
    643                 for (int i=0; i < nxy; i++) {
    644                     fin.getline(line,sizeof(line)-1);
    645                     if (sscanf(line, "%lg %lg %lg", &xx, &yy, &zz) == 3) {
    646                         xymesh.addNode( Rappture::Node2D(xx,yy) );
    647                     }
    648                 }
    649 
    650                 char fpts[128];
    651                 sprintf(fpts, "/tmp/tmppts%d", getpid());
    652                 char fcells[128];
    653                 sprintf(fcells, "/tmp/tmpcells%d", getpid());
    654 
    655                 std::ofstream ftmp(fpts);
    656                 // save corners of bounding box first, to work around meshing
    657                 // problems in voronoi utility
    658                 ftmp << xymesh.rangeMin(Rappture::xaxis) << " "
    659                      << xymesh.rangeMin(Rappture::yaxis) << std::endl;
    660                 ftmp << xymesh.rangeMax(Rappture::xaxis) << " "
    661                      << xymesh.rangeMin(Rappture::yaxis) << std::endl;
    662                 ftmp << xymesh.rangeMax(Rappture::xaxis) << " "
    663                      << xymesh.rangeMax(Rappture::yaxis) << std::endl;
    664                 ftmp << xymesh.rangeMin(Rappture::xaxis) << " "
    665                      << xymesh.rangeMax(Rappture::yaxis) << std::endl;
    666                 for (int i=0; i < nxy; i++) {
    667                     ftmp << xymesh.atNode(i).x() << " " << xymesh.atNode(i).y() << std::endl;
    668                
    669                 }
    670                 ftmp.close();
    671 
    672                 char cmdstr[512];
    673                 sprintf(cmdstr, "voronoi -t < %s > %s", fpts, fcells);
    674                 if (system(cmdstr) == 0) {
    675                     int cx, cy, cz;
    676                     std::ifstream ftri(fcells);
    677                     while (!ftri.eof()) {
    678                         ftri.getline(line,sizeof(line)-1);
    679                         if (sscanf(line, "%d %d %d", &cx, &cy, &cz) == 3) {
    680                             if (cx >= 4 && cy >= 4 && cz >= 4) {
    681                                 // skip first 4 boundary points
    682                                 xymesh.addCell(cx-4, cy-4, cz-4);
     1009                            {
     1010                                nzero_min = v;
    6831011                            }
    684                         }
    685                     }
    686                     ftri.close();
    687                 } else {
    688                     return result.error("triangularization failed");
    689                 }
    690 
    691                 sprintf(cmdstr, "rm -f %s %s", fpts, fcells);
    692                 system(cmdstr);
    693             } else if (sscanf(start, "object %d class regulararray count %d", &dummy, &nz) == 2) {
    694                 // found z-grid
    695             } else if (sscanf(start, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
    696                 // found origin
    697             } else if (sscanf(start, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
    698                 // found one of the delta lines
    699                 if (ddx != 0.0) { dx = ddx; }
    700                 else if (ddy != 0.0) { dy = ddy; }
    701                 else if (ddz != 0.0) { dz = ddz; }
    702             } else if (sscanf(start, "object %d class array type %s rank 0 items %d data follows", &dummy, type, &npts) == 3) {
    703                 if (isrect && (npts != nx*ny*nz)) {
    704                     char mesg[256];
    705                     sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, npts);
    706                     return result.error(mesg);
    707                 } else if (!isrect && (npts != nxy*nz)) {
    708                     char mesg[256];
    709                     sprintf(mesg,"inconsistent data: expected %d points but found %d points", nxy*nz, npts);
    710                     return result.error(mesg);
    711                 }
    712                 break;
    713             } else if (sscanf(start, "object %d class array type %s rank 0 times %d data follows", &dummy, type, &npts) == 3) {
    714                 if (npts != nx*ny*nz) {
    715                     char mesg[256];
    716                     sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, npts);
    717                     return result.error(mesg);
    718                 }
    719                 break;
    720             }
    721         }
    722     }
    723 
    724     // read data points
    725     if (!fin.eof()) {
    726         if (isrect) {
    727             Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
    728             Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
    729             Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
    730             Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
    731 
    732             double dval[6];
    733             int nread = 0;
    734             int ix = 0;
    735             int iy = 0;
    736             int iz = 0;
    737             while (!fin.eof() && nread < npts) {
    738                 fin.getline(line,sizeof(line)-1);
    739                 if (fin.fail()) {
    740                     return result.error("error reading data points");
    741                 }
    742                 int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
    743 
    744                 for (int p=0; p < n; p++) {
    745                     int nindex = iz*nx*ny + iy*nx + ix;
    746                     field.define(nindex, dval[p]);
    747                     nread++;
    748                     if (++iz >= nz) {
    749                         iz = 0;
    750                         if (++iy >= ny) {
    751                             iy = 0;
    752                             ++ix;
    753                         }
    754                     }
    755                 }
    756             }
    757 
    758             // make sure that we read all of the expected points
    759             if (nread != nx*ny*nz) {
    760                 char mesg[256];
    761                 sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, nread);
    762                 result.error(mesg);
    763                 return result;
    764             }
    765 
    766             // figure out a good mesh spacing
    767             int nsample = 30;
    768             dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
    769             dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
    770             dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
    771             double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
    772 
    773             nx = (int)ceil(dx/dmin);
    774             ny = (int)ceil(dy/dmin);
    775             nz = (int)ceil(dz/dmin);
    776 
    777 #ifndef NV40
    778             // must be an even power of 2 for older cards
    779                 nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    780                 ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    781                 nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    782 #endif
    783 
    784             float *cdata = new float[nx*ny*nz];
    785             int ngen = 0;
    786             double nzero_min = 0.0;
    787             for (int iz=0; iz < nz; iz++) {
    788                 double zval = z0 + iz*dmin;
    789                 for (int iy=0; iy < ny; iy++) {
    790                     double yval = y0 + iy*dmin;
    791                     for (int ix=0; ix < nx; ix++) {
    792                         double xval = x0 + ix*dmin;
    793                         double v = field.value(xval,yval,zval);
    794 
    795                         if (v != 0.0f && v < nzero_min) {
    796                             nzero_min = v;
    797                         }
    798 
    799                         // scale all values [0-1], -1 => out of bounds
    800                         v = (isnan(v)) ? -1.0 : v;
    801 
    802                         cdata[ngen] = v;
    803                         ++ngen;
    804                     }
    805                 }
    806             }
    807 
    808             float* data = computeGradient(cdata, nx, ny, nz, field.valueMin(),
    809                                           field.valueMax());
    810 
    811             // Compute the gradient of this data.  BE CAREFUL: center
    812             /*
    813             float *data = new float[4*nx*ny*nz];
    814 
    815             double vmin = field.valueMin();
    816             double dv = field.valueMax() - field.valueMin();
    817             if (dv == 0.0) { dv = 1.0; }
    818 
    819             // generate the uniformly sampled data that we need for a volume
    820             int ngen = 0;
    821             double nzero_min = 0.0;
    822             for (int iz=0; iz < nz; iz++) {
    823                 double zval = z0 + iz*dmin;
    824                 for (int iy=0; iy < ny; iy++) {
    825                     double yval = y0 + iy*dmin;
    826                     for (int ix=0; ix < nx; ix++) {
    827                         double xval = x0 + ix*dmin;
    828                         double v = field.value(xval,yval,zval);
    829 
    830                         if (v != 0.0f && v < nzero_min)
    831                         {
    832                             nzero_min = v;
    833                         }
    834 
    835                         // scale all values [0-1], -1 => out of bounds
    836                         v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
    837 
    838                         data[ngen] = v;
    839                         ngen += 4;
    840                     }
    841                 }
    842             }
    843             // Compute the gradient of this data.  BE CAREFUL: center
    844             // calculation on each node to avoid skew in either direction.
    845             ngen = 0;
    846             for (int iz=0; iz < nz; iz++) {
    847                 for (int iy=0; iy < ny; iy++) {
    848                     for (int ix=0; ix < nx; ix++) {
    849                         // gradient in x-direction
    850                         double valm1 = (ix == 0) ? 0.0 : data[ngen-4];
    851                         double valp1 = (ix == nx-1) ? 0.0 : data[ngen+4];
    852                         if (valm1 < 0 || valp1 < 0) {
    853                             data[ngen+1] = 0.0;
    854                         } else {
    855                             data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
    856                         }
    857 
    858                         // gradient in y-direction
    859                         valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
    860                         valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
    861                         if (valm1 < 0 || valp1 < 0) {
    862                             data[ngen+2] = 0.0;
    863                         } else {
    864                             //data[ngen+2] = valp1-valm1; // assume dy=1
    865                             data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
    866                         }
    867 
    868                         // gradient in z-direction
    869                         valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
    870                         valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
    871                         if (valm1 < 0 || valp1 < 0) {
    872                             data[ngen+3] = 0.0;
    873                         } else {
    874                             //data[ngen+3] = valp1-valm1; // assume dz=1
    875                             data[ngen+3] = ((valp1-valm1) + 1) *  0.5; // assume dz=1
    876                         }
    877 
    878                         ngen += 4;
    879                     }
    880                 }
    881             }
    882             */
    883 
    884             NanoVis::load_volume(index, nx, ny, nz, 4, data,
    885                 field.valueMin(), field.valueMax(), nzero_min);
    886 
    887             // TBD..
    888             // POINTSET
    889             /*
    890             PointSet* pset = new PointSet();
    891             pset->initialize(volume[index], (float*) data);
    892             pset->setVisible(true);
    893             NanoVis::pointSet.push_back(pset);
    894             updateColor(pset);
    895             NanoVis::volume[index]->pointsetIndex = NanoVis::pointSet.size() - 1;
    896             */
    897  
    898             delete [] data;
    899 
    900         } else {
    901             Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
    902             Rappture::FieldPrism3D field(xymesh, zgrid);
    903 
    904             double dval;
    905             int nread = 0;
    906             int ixy = 0;
    907             int iz = 0;
    908             while (!fin.eof() && nread < npts) {
    909                 fin >> dval;
    910                 if (fin.fail()) {
    911                     char mesg[256];
    912                     sprintf(mesg,"after %d of %d points: can't read number",
    913                             nread, npts);
    914                     return result.error(mesg);
    915                 } else {
    916                     int nid = nxy*iz + ixy;
    917                     field.define(nid, dval);
    918 
    919                     nread++;
    920                     if (++iz >= nz) {
    921                         iz = 0;
    922                         ixy++;
    923                     }
    924                 }
    925             }
    926 
    927             // make sure that we read all of the expected points
    928             if (nread != nxy*nz) {
    929                 char mesg[256];
    930                 sprintf(mesg,"inconsistent data: expected %d points but found %d points", nxy*nz, nread);
    931                 return result.error(mesg);
    932             }
    933 
    934             // figure out a good mesh spacing
    935             int nsample = 30;
    936             x0 = field.rangeMin(Rappture::xaxis);
    937             dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
    938             y0 = field.rangeMin(Rappture::yaxis);
    939             dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
    940             z0 = field.rangeMin(Rappture::zaxis);
    941             dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
    942             double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
    943 
    944             nx = (int)ceil(dx/dmin);
    945             ny = (int)ceil(dy/dmin);
    946             nz = (int)ceil(dz/dmin);
    947 #ifndef NV40
    948             // must be an even power of 2 for older cards
    949                 nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    950                 ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    951                 nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    952 #endif
    953             float *data = new float[4*nx*ny*nz];
    954 
    955             double vmin = field.valueMin();
    956             double dv = field.valueMax() - field.valueMin();
    957             if (dv == 0.0) { dv = 1.0; }
    958 
    959             // generate the uniformly sampled data that we need for a volume
    960             int ngen = 0;
    961             double nzero_min = 0.0;
    962             for (iz=0; iz < nz; iz++) {
    963                 double zval = z0 + iz*dmin;
    964                 for (int iy=0; iy < ny; iy++) {
    965                     double yval = y0 + iy*dmin;
    966                     for (int ix=0; ix < nx; ix++) {
    967                         double xval = x0 + ix*dmin;
    968                         double v = field.value(xval,yval,zval);
    969 
    970                         if (v != 0.0f && v < nzero_min)
    971                         {
    972                             nzero_min = v;
    973                         }
    9741012                        // scale all values [0-1], -1 => out of bounds
    9751013                        v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
    … …  
    10221060            }
    10231061
    1024                 NanoVis::load_volume(index, nx, ny, nz, 4, data,
    1025                 field.valueMin(), field.valueMax(), nzero_min);
     1062            Volume *volPtr;
     1063            volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
     1064                field.valueMin(), field.valueMax(), nzero_min);
     1065            volPtr->set_limits(0, field.rangeMin(Rappture::xaxis),
     1066                               field.rangeMax(Rappture::xaxis));
     1067            volPtr->set_limits(1, field.rangeMin(Rappture::yaxis),
     1068                               field.rangeMax(Rappture::yaxis));
     1069            volPtr->set_limits(2, field.rangeMin(Rappture::zaxis),
     1070                               field.rangeMax(Rappture::zaxis));
    10261071
    10271072            // TBD..
    10281073            // POINTSET
    10291074            /*
    1030             PointSet* pset = new PointSet();
    1031             pset->initialize(volume[index], (float*) data);
    1032             pset->setVisible(true);
    1033             NanoVis::pointSet.push_back(pset);
    1034             updateColor(pset);
    1035             NanoVis::volume[index]->pointsetIndex = NanoVis::pointSet.size() - 1;
     1075              PointSet* pset = new PointSet();
     1076              pset->initialize(volume[index], (float*) data);
     1077              pset->setVisible(true);
     1078              NanoVis::pointSet.push_back(pset);
     1079              updateColor(pset);
     1080              NanoVis::volume[index]->pointsetIndex = NanoVis::pointSet.size() - 1;
    10361081            */
    10371082 

  • trunk/vizservers/nanovis/nanovis.cpp

    r923 r927  
    273273 * width, height and depth: number of points in each dimension
    274274 */
    275 void
     275Volume *
    276276NanoVis::load_volume(int index, int width, int height, int depth,
    277277                     int n_component, float* data, double vmin,
    … …  
    287287        volume[index] = NULL;
    288288
    289         if (vol->pointsetIndex != -1)
    290         {
    291             if (((unsigned  int) vol->pointsetIndex) < pointSet.size() && pointSet[vol->pointsetIndex] != NULL)
    292             {
     289        if (vol->pointsetIndex != -1) {
     290            if (((unsigned  int) vol->pointsetIndex) < pointSet.size() &&
     291                pointSet[vol->pointsetIndex] != NULL) {
    293292                delete pointSet[vol->pointsetIndex];
    294293                pointSet[vol->pointsetIndex] = 0;
    295294            }
    296295        }
    297 
    298296        delete vol;
    299297    }
    300 
    301298    volume[index] = new Volume(0.f, 0.f, 0.f, width, height, depth, 1.,
    302                                n_component, data, vmin, vmax, nzero_min);
    303     assert(volume[index]!=0);
     299        n_component, data, vmin, vmax, nzero_min);
     300    return volume[index];
    304301}
    305302

  • trunk/vizservers/nanovis/nanovis.h

    r902 r927  
    102102class NanoVis {
    103103public:
     104    enum Axis { X, Y, Z };
    104105    static VolumeRenderer* vol_renderer;
    105106    static PointSetRenderer* pointset_renderer;
    … …  
    158159    static int render_legend(TransferFunction *tf, double min, double max,
    159160        int width, int height, const char* volArg);
    160     static void load_volume(int index, int width, int height, int depth,
     161    static Volume *load_volume(int index, int width, int height, int depth,
    161162        int n, float* data, double vmin, double vmax, double nzero_min);
    162163#ifndef XINETD
Note: See TracChangeset for help on using the changeset viewer.