Changeset 1380


Ignore:
Timestamp:
Apr 4, 2009 4:49:00 PM (13 years ago)
Author:
gah
Message:
 
Location:
trunk/packages/vizservers
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanoscale/server.c

    r1278 r1380  
    7575            _x > _y ? _x : _y; })
    7676
     77#ifdef notdef
    7778static int
    7879find_best_host(void)
     
    103104    return index;
    104105}
     106#endif
    105107
    106108static void
     
    572574                // accept the connection.
    573575                msg = 0;
    574                 write(i, &msg, 4);
     576                if (write(i, &msg, 4) != 4) {
     577                    fprintf(stderr, "short write for hostname\n");
     578                }
    575579             
    576580                int pair[2];
  • trunk/packages/vizservers/nanovis/Command.cpp

    r1374 r1380  
    17531753            return TCL_ERROR;
    17541754        }
     1755#ifdef notdef
    17551756    } else if (strncmp(buf.bytes(), "<unirect3d>", 4) == 0) {
     1757
    17561758        Rappture::Unirect3d data;
    17571759        Tcl_CmdInfo cmdInfo;
     
    17751777            return TCL_ERROR;
    17761778        }
     1779#endif
    17771780    }
    17781781
  • trunk/packages/vizservers/nanovis/FlowCmds.cpp

    r1374 r1380  
    7171#include "NvLIC.h"
    7272#include "Unirect.h"
    73 
    74 struct Stream {
    75     float position;
    76     bool hide;
    77     int axis;
    78 };
    79 
    80 struct InitStream {
    81     const char *name;
    82     Tcl_HashEntry *hashPtr;
    83     bool hide;
    84     float position;
    85 };
    86 
    87 struct FlowCmd {
    88     const char *name;
    89     Tcl_HashEntry *hashPtr;
    90     Volume *volPtr;
    91     Stream streams[3];          // Stream for each axis-aligned plane;
    92     bool lic;
    93     bool hide;
    94     Tcl_HashTable injectTable;
    95     Tcl_Command cmdToken;
    96 };
    97 
    98 extern int GetDataStream(Tcl_Interp *interp, Rappture::Buffer &buf, int nBytes);
    99 extern bool load_vector_stream2(Rappture::Outcome &result, int index,
    100         size_t nBytes, char *bytes);
    101 
    102 extern bool MakeVectorFieldFromUnirect3d(Rappture::Outcome &result,
    103         Rappture::Unirect3d &data);
    104 
    105 extern int GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
    106         bool *boolPtr);
    107 extern int GetFloatFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
    108         float *floatPtr);
    109 extern int GetAxisFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
    110         int *axisPtr);
    111 extern int GetVolumeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
    112         Volume **volumePtrPtr);
     73#include "FlowCmd.h"
    11374
    11475static Tcl_HashTable flowTable;
     
    13495               Tcl_Obj *const *objv)
    13596{
    136     Rappture::Outcome result;
     97    Rappture::Outcome context;
    13798
    13899    const char *fileName;
     
    145106    }
    146107    Rappture::Buffer buf;
    147     if (!buf.load(result, fileName)) {
     108    if (!buf.load(context, fileName)) {
    148109        Tcl_AppendResult(interp, "can't load data from \"", fileName, "\": ",
    149                          result.remark(), (char *)NULL);
    150         return TCL_ERROR;
    151     }
    152 
    153     int n = NanoVis::n_volumes;
     110                         context.remark(), (char *)NULL);
     111        return TCL_ERROR;
     112    }
     113
     114    FlowCmd *flowPtr = (FlowCmd *)clientData;
    154115    if (strncmp(buf.bytes(), "<DX>", 4) == 0) {
    155         if (!load_vector_stream2(result, n, buf.size(), (char *)buf.bytes())) {
    156             Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     116        Rappture::Unirect3d data;
     117        if (!load_vector_stream2(context, buf.size(), (char *)buf.bytes(),
     118                                 data)) {
     119            Tcl_AppendResult(interp, context.remark(), (char *)NULL);
    157120            return TCL_ERROR;
    158121        }
     122        flowPtr->dataPtr = &data;
    159123    } else if (strncmp(buf.bytes(), "<unirect3d>", 4) == 0) {
    160124        Rappture::Unirect3d data;
     
    175139            return TCL_ERROR;
    176140        }
    177         if (!MakeVectorFieldFromUnirect3d(result, data)) {
    178             Tcl_AppendResult(interp, result.remark(), (char *)NULL);
    179             return TCL_ERROR;
    180         }
    181     }
    182     FlowCmd *flowPtr = (FlowCmd *)clientData;
    183 
    184     if (flowPtr->volPtr != NULL) {
    185         // You might have to remove the volume from the particle renderer.
    186         delete flowPtr->volPtr;
    187     }
     141        flowPtr->dataPtr = &data;
     142    }
     143
     144#ifdef notdef
    188145    flowPtr->volPtr = NanoVis::volume[NanoVis::n_volumes];
    189146    //
     
    209166    float dz0 = -0.5*flowPtr->volPtr->depth/flowPtr->volPtr->width;
    210167    flowPtr->volPtr->move(Vector3(dx0, dy0, dz0));
     168#endif
    211169    return TCL_OK;
    212170}
     
    216174                    Tcl_Obj *const *objv)
    217175{
    218     Rappture::Outcome result;
     176    Rappture::Outcome context;
    219177
    220178    Trace("Flow Data Loading\n");
     
    232190        return TCL_ERROR;
    233191    }
    234     int n = NanoVis::n_volumes;
     192    FlowCmd *flowPtr = (FlowCmd *)clientData;
    235193    if (strncmp(buf.bytes(), "<DX>", 4) == 0) {
    236         if (!load_vector_stream2(result, n, buf.size(), (char *)buf.bytes())) {
    237             Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     194        if (!load_vector_stream2(context, buf.size(), (char *)buf.bytes(),
     195                flowPtr)) {
     196            Tcl_AppendResult(interp, context.remark(), (char *)NULL);
    238197            return TCL_ERROR;
    239198        }
     
    256215            return TCL_ERROR;
    257216        }
    258         if (!MakeVectorFieldFromUnirect3d(result, data)) {
    259             Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     217        if (!SetVectorFieldDataFromUnirect3d(context, data, flowPtr)) {
     218            Tcl_AppendResult(interp, context.remark(), (char *)NULL);
    260219            return TCL_ERROR;
    261220        }
    262221    }
    263     FlowCmd *flowPtr = (FlowCmd *)clientData;
    264 
    265222    if (flowPtr->volPtr != NULL) {
    266223        delete flowPtr->volPtr;
    267224    }
     225    #ifdef notdef
     226    // FIXME: Move this to flow pending routine.
     227
    268228    flowPtr->volPtr = NanoVis::volume[NanoVis::n_volumes];
    269229    //
     
    289249    float dz0 = -0.5*flowPtr->volPtr->depth/flowPtr->volPtr->width;
    290250    flowPtr->volPtr->move(Vector3(dx0, dy0, dz0));
     251    #endif
    291252    return TCL_OK;
    292253}
     
    316277{
    317278    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
    318         offsetof(Stream, hide), 0},
     279        offsetof(Stream, hidden), 0},
    319280    {Rappture::SWITCH_FLOAT, "-position", "number",
    320281        offsetof(Stream, position), 0},
     
    429390{
    430391    {Rappture::SWITCH_BOOLEAN, "-lic", "boolean",
    431         offsetof(FlowCmd, hide), 0},
     392        offsetof(FlowCmd, lic), 0},
     393    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
     394        offsetof(FlowCmd, hidden), 0},
    432395    {Rappture::SWITCH_END}
    433396};
     
    452415{
    453416    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
    454         offsetof(InitStream, hide), 0},
     417        offsetof(InitStream, hidden), 0},
    455418    {Rappture::SWITCH_FLOAT, "-position", "number",
    456419        offsetof(InitStream, position), 0},
     
    603566 *---------------------------------------------------------------------------
    604567 *
     568 * FlowShapeOp--
     569 *
     570 *      This procedure is invoked to process commands on behalf of the flow
     571 *      object.
     572 *
     573 * Results:
     574 *      A standard Tcl result.
     575 *
     576 * Side effects:
     577 *      See the user documentation.
     578 *
     579 *---------------------------------------------------------------------------
     580 */
     581static Rappture::CmdSpec flowShapeOps[] = {
     582    {"add",        1, FlowInjectorAddOp,        3, 0, "name ?switches?",},
     583    {"configure",  1, FlowInjectorConfigureOp,  3, 5, "name ?switches?",},
     584    {"delete",     1, FlowInjectorDeleteOp,     3, 0, "?name...?"},
     585    {"names",      1, FlowInjectorNamesOp,      3, 4, "?pattern?"},
     586};
     587
     588static int nFlowShapeOps = NumCmdSpecs(flowShapeOps);
     589
     590static int
     591FlowShapeOp(ClientData clientData, Tcl_Interp *interp, int objc,
     592               Tcl_Obj *const *objv)
     593{
     594    Tcl_ObjCmdProc *proc;
     595    proc = Rappture::GetOpFromObj(interp, nFlowShapeOps, flowShapeOps,
     596        Rappture::CMDSPEC_ARG1, objc, objv, 0);
     597    if (proc == NULL) {
     598        return TCL_ERROR;
     599    }
     600    FlowCmd *flowPtr = (FlowCmd *)clientData;
     601    Tcl_Preserve(flowPtr);
     602    int result;
     603    result = (*proc) (clientData, interp, objc, objv);
     604    Tcl_Release(flowPtr);
     605    return result;
     606}
     607
     608/*
     609 *---------------------------------------------------------------------------
     610 *
    605611 * FlowInstObjCmd --
    606612 *
     
    621627    {"injector",    1, FlowInjectorOp,   3, 0, "oper ?args?",},
    622628    {"particles",   1, FlowParticlesOp,  3, 0, "oper ?args?",},
    623     {"stream",      1, FlowStreamOp,     4, 0, "oper axis ?args?",},
     629    {"shape",       2, FlowShapeOp,      3, 0, "oper ?args?",},
     630    {"stream",      2, FlowStreamOp,     4, 0, "oper axis ?args?",},
    624631};
    625632static int nFlowInstOps = NumCmdSpecs(flowInstOps);
     
    708715        (Tcl_ObjCmdProc *)FlowInstObjCmd, flowPtr, FlowInstDeleteProc);
    709716    Tcl_SetHashValue(hPtr, flowPtr);
    710 
    711717    flowPtr->volPtr = NULL;
    712718    return TCL_OK;
     
    734740        }
    735741        Tcl_DeleteCommandFromToken(interp, flowPtr->cmdToken);
     742#ifdef notdef
     743        NanoVis::flowVisRenderer->removeVectorField(flowPtr);
     744#endif
    736745        delete flowPtr;
    737746    }
     747    return TCL_OK;
     748}
     749
     750/*
     751 *---------------------------------------------------------------------------
     752 *
     753 * FlowInitOp --
     754 *
     755 *---------------------------------------------------------------------------
     756 */
     757/*ARGSUSED*/
     758static int
     759FlowInitOp(ClientData clientData, Tcl_Interp *interp, int objc,
     760           Tcl_Obj *const *objv)
     761{
     762    Tcl_Obj *listObjPtr;
     763    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
     764
     765    Tcl_HashEntry *hPtr;
     766    Tcl_HashSearch iter;
     767    for (hPtr = Tcl_FirstHashEntry(&flowTable, &iter); hPtr != NULL;
     768        hPtr = Tcl_NextHashEntry(&iter)) {
     769        FlowCmd *flowPtr;
     770        flowPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
     771        if (flowPtr->fieldPtr != NULL) {
     772            delete flowPtr->fieldPtr; // Remove the vector field.
     773            flowPtr->fieldPtr = NULL;
     774        }
     775    }
     776#ifdef notdef
     777    // For each flow vector enabled in the table add it to the renderer.
     778    for (hPtr = Tcl_FirstHashEntry(&flowTable, &iter); hPtr != NULL;
     779        hPtr = Tcl_NextHashEntry(&iter)) {
     780        FlowCmd *flowPtr;
     781        flowPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
     782        if (flowPtr->hidden) {
     783            continue;           // Flow is hidden.
     784        }
     785        if (flowPtr->volPtr == NULL) {
     786            continue;
     787        }
     788        volPtr->set_n_slice(256-n);
     789        // volPtr->set_n_slice(512-n);
     790        volPtr->disable_cutplane(0);
     791        volPtr->disable_cutplane(1);
     792        volPtr->disable_cutplane(2);
     793           
     794        NanoVis::vol_renderer->add_volume(volPtr,
     795                NanoVis::get_transfunc("default"));
     796        float dx0 = -0.5;
     797        float dy0 = -0.5*volPtr->height/volPtr->width;
     798        float dz0 = -0.5*volPtr->depth/volPtr->width;
     799        volPtr->move(Vector3(dx0, dy0, dz0));
     800        //volPtr->enable_data();
     801        volPtr->disable_data();
     802        NvVectorField *fieldPtr;
     803        fieldPtr = NanoVis::flowVisRenderer->addVectorField(volPtr,
     804                *(volPtr->get_location()), 1.0f,
     805                volPtr->height / (float)volPtr->width,
     806                volPtr->depth  / (float)volPtr->width,
     807                1.0f);
     808        NanoVis::flowVisRenderer->activateVectorField(fieldPtr);
     809           
     810        //////////////////////////////////
     811        // ADD Particle Injection Plane1
     812        NanoVis::flowVisRenderer->addPlane(fieldPtr, plane_name1);
     813        NanoVis::flowVisRenderer->setPlaneAxis(fieldPtr, plane_name1, 0);
     814        NanoVis::flowVisRenderer->setPlanePos(fieldPtr, plane_name1, 0.9);
     815        NanoVis::flowVisRenderer->setParticleColor(fieldPtr, plane_name1,
     816                                                   color1);
     817        // ADD Particle Injection Plane2
     818        NanoVis::flowVisRenderer->addPlane(fieldPtr, plane_name2);
     819        NanoVis::flowVisRenderer->setPlaneAxis(fieldPtr, plane_name2, 0);
     820        NanoVis::flowVisRenderer->setPlanePos(fieldPtr, plane_name2, 0.2);
     821        NanoVis::flowVisRenderer->setParticleColor(fieldPtr, plane_name2,
     822                                                   color2);
     823        NanoVis::flowVisRenderer->initialize(fieldPtr);
     824           
     825        NanoVis::flowVisRenderer->activatePlane(fieldPtr, plane_name1);
     826        NanoVis::flowVisRenderer->activatePlane(fieldPtr, plane_name2);
     827           
     828        NanoVis::licRenderer->setVectorField(volPtr->id,
     829                                *(volPtr->get_location()),
     830                                1.0f / volPtr->aspect_ratio_width,
     831                                1.0f / volPtr->aspect_ratio_height,
     832                                1.0f / volPtr->aspect_ratio_depth,
     833                                volPtr->wAxis.max());
     834        }
     835    }
     836        const char *name;
     837        name = Tcl_GetCommandName(interp, flowPtr->cmdToken);
     838        Tcl_Obj *objPtr;
     839        objPtr = Tcl_NewStringObj(name, -1);
     840        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
     841    }
     842    Tcl_SetObjResult(interp, listObjPtr);
     843#endif
    738844    return TCL_OK;
    739845}
     
    860966    Trace("FLOW started\n");
    861967
    862     Rappture::Outcome result;
     968    Rappture::Outcome context;
    863969    Rappture::AVTranslate movie(width, height, frameRate, bitRate);
    864970
     
    868974    }
    869975
    870     movie.init(result, fileName);
     976    movie.init(context, fileName);
    871977
    872978    for (int i = 0; i < numFrames; i++) {
     
    888994        // This is done before bmp_write_to_file because bmp_write_to_file
    889995        // turns rgb data to bgr
    890         movie.append(result, NanoVis::screen_buffer, pad);
     996        movie.append(context, NanoVis::screen_buffer, pad);
    891997        // NanoVis::bmp_write_to_file(frame_count, fileName);
    892998    }
    893999
    894     movie.done(result);
     1000    movie.done(context);
    8951001    Trace("FLOW end\n");
    8961002
     
    9051011    // FIXME: find a way to get the data from the movie object as a void*
    9061012    Rappture::Buffer data;
    907     if (!data.load(result, fileName)) {
     1013    if (!data.load(context, fileName)) {
    9081014        Tcl_AppendResult(interp, "can't load data from temporary movie file \"",
    909                 fileName, "\": ", result.remark(), (char *)NULL);
     1015                fileName, "\": ", context.remark(), (char *)NULL);
    9101016        return TCL_ERROR;
    9111017    }
     
    9341040    {"add",      1, FlowAddOp,     2, 3, "?name? ?option value...?",},
    9351041    {"delete",   1, FlowDeleteOp,  2, 0, "name...",},
     1042    {"init",     1, FlowInitOp,    2, 2, "",},
    9361043    {"names",    1, FlowNamesOp,   2, 3, "?pattern?",},
    9371044    {"next",     2, FlowNextOp,    2, 2, "",},
     
    9801087    return TCL_OK;
    9811088}
     1089
     1090#ifdef notdef
     1091void
     1092MapFlowVectors(Tcl_Interp *interp)
     1093{
     1094    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
     1095
     1096    if (debug_flag) {
     1097        fprintf(stderr, "in SetHeightmapRanges\n");
     1098    }
     1099    xMin = yMin = zMin = wMin = DBL_MAX;
     1100    xMax = yMax = zMax = wMax = -DBL_MAX;
     1101    Tcl_HashEntry *hPtr;
     1102    Tcl_HashSearch iter;
     1103    for (hPtr = Tcl_FirstHashEntry(&flowTable, &iter); hPtr != NULL;
     1104        hPtr = Tcl_NextHashEntry(&iter)) {
     1105        FlowCmd *flowPtr;
     1106        flowPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
     1107
     1108        flowPtr->
     1109
     1110    for (unsigned int i = 0; i < heightMap.size(); i++) {
     1111        HeightMap *hmPtr;
     1112
     1113        hmPtr = heightMap[i];
     1114        if (hmPtr == NULL) {
     1115            continue;
     1116        }
     1117        if (xMin > hmPtr->xAxis.min()) {
     1118            xMin = hmPtr->xAxis.min();
     1119        }
     1120        if (xMax < hmPtr->xAxis.max()) {
     1121            xMax = hmPtr->xAxis.max();
     1122        }
     1123        if (yMin > hmPtr->yAxis.min()) {
     1124            yMin = hmPtr->yAxis.min();
     1125        }
     1126        if (yMax < hmPtr->yAxis.max()) {
     1127            yMax = hmPtr->yAxis.max();
     1128        }
     1129        if (zMin > hmPtr->zAxis.min()) {
     1130            zMin = hmPtr->zAxis.min();
     1131        }
     1132        if (zMax < hmPtr->zAxis.max()) {
     1133            zMax = hmPtr->zAxis.max();
     1134        }
     1135        if (wMin > hmPtr->wAxis.min()) {
     1136            wMin = hmPtr->wAxis.min();
     1137        }
     1138        if (wMax < hmPtr->wAxis.max()) {
     1139            wMax = hmPtr->wAxis.max();
     1140        }
     1141    }
     1142    if ((xMin < DBL_MAX) && (xMax > -DBL_MAX)) {
     1143        grid->xAxis.SetScale(xMin, xMax);
     1144    }
     1145    if ((yMin < DBL_MAX) && (yMax > -DBL_MAX)) {
     1146        grid->yAxis.SetScale(yMin, yMax);
     1147    }
     1148    if ((zMin < DBL_MAX) && (zMax > -DBL_MAX)) {
     1149        grid->zAxis.SetScale(zMin, zMax);
     1150    }
     1151    if ((wMin < DBL_MAX) && (wMax > -DBL_MAX)) {
     1152        HeightMap::valueMin = grid->yAxis.min();
     1153        HeightMap::valueMax = grid->yAxis.max();
     1154    }
     1155    for (unsigned int i = 0; i < heightMap.size(); i++) {
     1156        HeightMap *hmPtr;
     1157
     1158        hmPtr = heightMap[i];
     1159        if (hmPtr == NULL) {
     1160            continue;
     1161        }
     1162        hmPtr->MapToGrid(grid);
     1163    }
     1164    HeightMap::update_pending = false;
     1165    if (debug_flag) {
     1166        fprintf(stderr, "leaving SetHeightmapRanges\n");
     1167    }
     1168}
     1169
     1170    Tcl_Obj *listObjPtr;
     1171    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
     1172
     1173    Tcl_HashEntry *hPtr;
     1174    Tcl_HashSearch iter;
     1175    for (hPtr = Tcl_FirstHashEntry(&flowTable, &iter); hPtr != NULL;
     1176        hPtr = Tcl_NextHashEntry(&iter)) {
     1177        FlowCmd *flowPtr;
     1178        flowPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
     1179        if (flowPtr->fieldPtr != NULL) {
     1180            delete flowPtr->fieldPtr; // Remove the vector field.
     1181            flowPtr->fieldPtr = NULL;
     1182        }
     1183    }
     1184
     1185
     1186            Volume *volPtr;
     1187            volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
     1188                        field.valueMin(), field.valueMax(), nzero_min);
     1189            volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
     1190                   field.rangeMax(Rappture::xaxis));
     1191            volPtr->yAxis.SetRange(field.rangeMin(Rappture::yaxis),
     1192                   field.rangeMax(Rappture::yaxis));
     1193            volPtr->zAxis.SetRange(field.rangeMin(Rappture::zaxis),
     1194                   field.rangeMax(Rappture::zaxis));
     1195            volPtr->wAxis.SetRange(field.valueMin(), field.valueMax());
     1196            volPtr->update_pending = true;
     1197            delete [] data;
     1198#endif
  • trunk/packages/vizservers/nanovis/LoadVector.cpp

    r1374 r1380  
    1010#include "Nv.h"
    1111#include "nanovis.h"
     12#include "FlowCmd.h"
    1213
    1314static INLINE char *
     
    3637    return line;
    3738}
     39
    3840bool
    39 MakeVectorField(Rappture::Outcome &result,
    40                 float xMin, float xMax, size_t xNum,
    41                 float yMin, float yMax, size_t yNum,
    42                 float zMin, float zMax, size_t zNum,
    43                 size_t nValues, float *values)
     41SetVectorFieldData(Rappture::Outcome &context,
     42                   float xMin, float xMax, size_t xNum,
     43                   float yMin, float yMax, size_t yNum,
     44                   float zMin, float zMax, size_t zNum,
     45                   size_t nValues, float *values, Unirect3d *dataPtr)
    4446{
    4547#ifdef notdef
     
    9597        }
    9698    }
    97    
    98     Volume *volPtr;
    99     int ivol = NanoVis::n_volumes;
    100     volPtr = NanoVis::load_volume(ivol, xNum, yNum, zNum, 4, data,
    101         min_mag, max_mag, 0);
    102     volPtr->xAxis.SetRange(xMin, xMax);
    103     volPtr->yAxis.SetRange(yMin, yMax);
    104     volPtr->zAxis.SetRange(zMin, zMax);
    105     volPtr->wAxis.SetRange(min_mag, max_mag);
    106     volPtr->update_pending = true;
    107     delete [] data;
     99    dataPtr->xMin(xMin);
     100    dataPtr->xMax(xMax);
     101    dataPtr->xNum(xNum);
     102    dataPtr->yMin(yMin);
     103    dataPtr->yMax(yMax);
     104    dataPtr->yNum(yNum);
     105    dataPtr->yMin(zMin);
     106    dataPtr->yMax(zMax);
     107    dataPtr->yNum(zNum);
     108    dataPtr->values(data);
     109    dataPtr->minMag = min_mag;
     110    dataPtr->maxMag = max_mag;
    108111    return true;
    109112}
    110113
    111114bool
    112 MakeResampledVectorField(Rappture::Outcome &result,
    113                          float xMin, float xMax, size_t xNum,
    114                          float yMin, float yMax, size_t yNum,
    115                          float zMin, float zMax, size_t zNum,
    116                          size_t nValues, float *values)
     115SetResampledVectorFieldData(Rappture::Outcome &context,
     116                            float xMin, float xMax, size_t xNum,
     117                            float yMin, float yMax, size_t yNum,
     118                            float zMin, float zMax, size_t zNum,
     119                            size_t nValues, float *values, FlowCmd *flowPtr)
    117120{
    118121    Rappture::Mesh1D xgrid(xMin, xMax, xNum);
     
    215218    }
    216219   
    217     Volume *volPtr;
    218     int ivol = NanoVis::n_volumes;
    219     volPtr = NanoVis::load_volume(ivol, xNum, yNum, zNum, 4, data,
    220         min_mag, max_mag, nzero_min);
    221     volPtr->xAxis.SetRange(xMin, xMax);
    222     volPtr->yAxis.SetRange(yMin, yMax);
    223     volPtr->zAxis.SetRange(zMin, zMax);
    224     volPtr->wAxis.SetRange(min_mag, max_mag);
    225     volPtr->update_pending = true;
    226     delete [] data;
     220    flowPtr->xMin = xMin;
     221    flowPtr->xMax = xMax;
     222    flowPtr->xNum = xNum;
     223    flowPtr->yMin = yMin;
     224    flowPtr->yMax = yMax;
     225    flowPtr->yNum = yNum;
     226    flowPtr->yMin = zMin;
     227    flowPtr->yMax = zMax;
     228    flowPtr->yNum = zNum;
     229    flowPtr->values = data;
     230    flowPtr->minMag = min_mag;
     231    flowPtr->maxMag = max_mag;
    227232    return true;
    228233}
    229234
    230235bool
    231 MakeVectorFieldFromUnirect3d(Rappture::Outcome &result,
    232                              Rappture::Unirect3d &grid)
    233 {
    234     return MakeVectorField(result,
    235         grid.xMin(), grid.xMax(), grid.xNum(),
    236         grid.yMin(), grid.yMax(), grid.yNum(),
    237         grid.zMin(), grid.zMax(), grid.zNum(),
    238         grid.nValues(), grid.values());
    239 }
     236SetVectorFieldDataFromUnirect3d(Rappture::Outcome &context,
     237                                Rappture::Unirect3d &grid, FlowCmd *flowPtr)
     238{
     239    flowPtr->dataPtr = gridPtr;
     240    return SetVectorFieldData(context,
     241                              grid.xMin(), grid.xMax(), grid.xNum(),
     242                              grid.yMin(), grid.yMax(), grid.yNum(),
     243                              grid.zMin(), grid.zMax(), grid.zNum(),
     244                              grid.nValues(), grid.values(), flowPtr);
     245 }
    240246
    241247
     
    245251 */
    246252bool
    247 load_vector_stream2(Rappture::Outcome &result, int ivol, size_t length,
    248                     char *string)
    249 {
     253load_vector_stream2(Rappture::Outcome &context, size_t length, char *string,
     254                    Unirect3d *dataPtr)
     255{
     256    Unirect3d data;
    250257    int nx, ny, nz, npts;
    251258    double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
     
    283290            printf("point %d\n", npts);
    284291            if (npts != nx*ny*nz) {
    285                 result.addError("inconsistent data: expected %d points"
     292                context.addError("inconsistent data: expected %d points"
    286293                                " but found %d points", nx*ny*nz, npts);
    287294                return false;
     
    291298                " times %d data follows", &npts) == 3) {
    292299            if (npts != nx*ny*nz) {
    293                 result.addError("inconsistent data: expected %d points"
     300                context.addError("inconsistent data: expected %d points"
    294301                                " but found %d points", nx*ny*nz, npts);
    295302                return false;
     
    353360    // make sure that we read all of the expected points
    354361    if (nRead != nx*ny*nz) {
    355         result.addError("inconsistent data: expected %d points"
     362        context.addError("inconsistent data: expected %d points"
    356363                        " but found %d points", nx*ny*nz, npts);
    357364        return false;
    358365    }
    359366    bool status;
    360     status = MakeVectorField(result, x0, x0 + nx, nx, y0, y0 + ny, ny,
    361         z0, z0 + ny, ny, nRead, srcData);
     367    status = SetVectorFieldData(context, x0, x0 + nx, nx, y0, y0 + ny,
     368        ny, z0, z0 + ny, ny, nRead, srcData, flowPtr);
    362369    delete [] srcData;
    363370    return status;
  • trunk/packages/vizservers/nanovis/Makefile.in

    r1374 r1380  
    104104                Event.o \
    105105                Switch.o \
    106                 FlowCmds.o \
     106                Unirect.o \
    107107                GradientFilter.o \
    108108                Grid.o \
    109109                HeightMap.o \
    110                 LoadVector.o \
    111                 Unirect.o \
    112110                Mat4x4.o \
    113111                Nv.o \
  • trunk/packages/vizservers/nanovis/NvFlowVisRenderer.cpp

    r1370 r1380  
    116116NvFlowVisRenderer::addVectorField(const std::string& vfName, Volume* volPtr, const Vector3& ori, float scaleX, float scaleY, float scaleZ, float max)
    117117{
    118         std::map<std::string, NvVectorField*>::iterator iter = _vectorFieldMap.find(vfName);
    119         if (iter != _vectorFieldMap.end())
    120         {
    121                 if ((*iter).second)
    122                 {
    123                         ((*iter).second)->setVectorField(volPtr, ori, scaleX, scaleY, scaleZ, max);
    124                 }
    125                 else
    126                 {
    127                         NvVectorField* vf = new NvVectorField();
    128                         _vectorFieldMap[vfName] = vf;
    129                         vf->setVectorField(volPtr, ori, scaleX, scaleY, scaleZ, max);
    130                 }
    131         }
    132         else
    133         {
    134                 NvVectorField* vf = new NvVectorField();
    135                 _vectorFieldMap[vfName] = vf;
    136                 vf->setVectorField(volPtr, ori, scaleX, scaleY, scaleZ, max);
    137                
    138         }
     118    std::map<std::string, NvVectorField*>::iterator iter = _vectorFieldMap.find(vfName);
     119    if (iter != _vectorFieldMap.end()) {
     120        if ((*iter).second) {
     121            ((*iter).second)->setVectorField(volPtr, ori, scaleX, scaleY, scaleZ, max);
     122        } else {
     123            NvVectorField* vf = new NvVectorField();
     124            _vectorFieldMap[vfName] = vf;
     125            vf->setVectorField(volPtr, ori, scaleX, scaleY, scaleZ, max);
     126        }
     127    } else {
     128        NvVectorField* vf = new NvVectorField();
     129        _vectorFieldMap[vfName] = vf;
     130        vf->setVectorField(volPtr, ori, scaleX, scaleY, scaleZ, max);
     131    }
    139132}
    140133
  • trunk/packages/vizservers/nanovis/NvParticleRenderer.cpp

    r1370 r1380  
    3030NvParticleRenderer::NvParticleRenderer(int w, int h, CGcontext context) :
    3131    scale(1, 1, 1),
    32     _activate(false),
    33     origin(0, 0, 0)
     32    origin(0, 0, 0),
     33    _activate(false)
    3434{
    3535    psys_width = w;
  • trunk/packages/vizservers/nanovis/R2/src/R2FilePath.cpp

    r1114 r1380  
    1717R2FilePath::R2FilePath()
    1818{
    19     char buff[255];
     19    char buff[BUFSIZ+2];
    2020#ifdef WIN32
    2121    _getcwd(buff, 255);
    2222#else
    23     getcwd(buff, 100);
     23    if (getcwd(buff, BUFSIZ) == NULL) {
     24        fprintf(stderr, "can't get current working directory\n");
     25    }
    2426#endif
    25     int length = strlen(buff);
     27    size_t length = strlen(buff);
    2628    buff[length] = '/';
    2729    buff[length + 1] = '\0';
    28 
    2930    _curDirectory = buff;
    30 
    3131}
    3232
  • trunk/packages/vizservers/nanovis/Trace.cpp

    r1204 r1380  
    1515    vsnprintf(buff, 1023, format, lst);
    1616    buff[1023] = '\0';
    17     printf(buff);
     17    fprintf(stdout, "%s\n", buff);
    1818    fflush(stdout);
    1919}
  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r1374 r1380  
    156156                }
    157157                line = getline(&p, endPtr);
    158                 if ((line == '#') || (line == '\0')) {
     158                if ((line[0] == '#') || (line[0] == '\0')) {
    159159                    continue;   // Skip blank or comment lines.
    160160                }
  • trunk/packages/vizservers/nanovis/dxReader2.cpp

    r1325 r1380  
    3535
    3636    f = fopen(dxfilename, "w");
    37     fwrite(buf, sizeof(char), nBytes, f);
     37
     38    ssize_t nWritten;
     39    nWritten = fwrite(buf, sizeof(char), nBytes, f);
    3840    fclose(f);
     41    if (nWritten != nBytes) {
     42        outcome.addError("Can't read %d bytes from file \"%s\"\n",
     43                         nBytes, dxfilename);
     44        return false;
     45    }
    3946
    4047    Rappture::DX dxObj(outcome, dxfilename);
  • trunk/packages/vizservers/nanovis/imgLoaders/BMPImageLoaderImpl.cpp

    r1196 r1380  
    2929
    3030    char header[54];
    31     fread(&header, 54, 1, f);
     31    if (fread(&header, 54, 1, f) != 1) {
     32        printf("can't read header of BMP file\n");
     33        return 0;
     34    };
    3235
    3336    if (header[0] != 'B' ||  header[1] != 'M') {
     
    6669        fseek(f,offset,SEEK_SET);
    6770        if (_targetImageFormat == Image::IMG_RGB) {
    68             fread(bytes,width*height*3,1,f); //24bit is easy
     71            if (fread(bytes,width*height*3,1,f) != 1) {
     72                fprintf(stderr, "can't read image data\n");
     73            }
    6974            for(x=0;x<width*height*3;x+=3)  { //except the format is BGR, grr
    7075                unsigned char temp = bytes[x];
     
    7479        } else if (_targetImageFormat == Image::IMG_RGBA) {
    7580            char* buff = (char*) malloc(width * height * sizeof(unsigned char) * 3);
    76             fread(buff,width*height*3,1,f);                 //24bit is easy
     81            if (fread(buff,width*height*3,1,f) != 1) {
     82                fprintf(stderr, "can't read BMP image data\n");
     83            }
    7784            for(x=0, y = 0;x<width*height*3;x+=3, y+=4)     {       //except the format is BGR, grr
    7885                bytes[y] = buff[x+2];
     
    8491        break;
    8592    case 8:
    86         fread(cols,256 * 4,1,f); //read colortable
     93        if (fread(cols,256 * 4,1,f) != 1) {
     94            fprintf(stderr, "can't read colortable from BMP file\n");
     95        }
    8796        fseek(f,offset,SEEK_SET); 
    8897        for(y=0;y<height;++y) { //(Notice 4bytes/col for some reason)
    8998            for(x=0;x<width;++x) {
    9099                unsigned char byte;                 
    91                 fread(&byte,1,1,f);                                                 //just read byte                                       
     100                if (fread(&byte,1,1,f) != 1) {
     101                    fprintf(stderr, "error reading BMP file\n");
     102                }
    92103                for(int c=0; c< 3; ++c) {
    93104                    //bytes[(y*width+x)*3+c] = cols[byte*4+2-c];        //and look up in the table
  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r1370 r1380  
    18051805
    18061806#ifdef NEW_FLOW_ENGINE
    1807 void addVectorField(const char* filename, const char* vf_name, const char* plane_name1, const char* plane_name2, const Vector4& color1, const Vector4& color2)
    1808 {
    1809                 Rappture::Outcome result;
    1810                 std::ifstream fdata;
    1811                 fdata.open(filename, std::ios::in);
    1812 
    1813                 int n = NanoVis::n_volumes;
    1814                 //fdata.write(buf.bytes(),buf.size());
    1815                 if (load_vector_stream2(result, n, fdata)) {
    1816                         Volume *volPtr = NanoVis::volume[n];
    1817                         if (volPtr != NULL) {
    1818                                 volPtr->set_n_slice(256-n);
    1819                                 // volPtr->set_n_slice(512-n);
    1820                                 volPtr->disable_cutplane(0);
    1821                                 volPtr->disable_cutplane(1);
    1822                                 volPtr->disable_cutplane(2);
    1823 
    1824                                 NanoVis::vol_renderer->add_volume(volPtr,
    1825                                         NanoVis::get_transfunc("default"));
    1826                                         float dx0 = -0.5;
    1827                                         float dy0 = -0.5*volPtr->height/volPtr->width;
    1828                                         float dz0 = -0.5*volPtr->depth/volPtr->width;
    1829                                         volPtr->move(Vector3(dx0, dy0, dz0));
    1830                                         //volPtr->enable_data();
    1831                                         volPtr->disable_data();
    1832                                 NanoVis::flowVisRenderer->addVectorField(vf_name, volPtr,
    1833                                                 *(volPtr->get_location()),
    1834                                                 1.0f,
    1835                                                 volPtr->height / (float)volPtr->width,
    1836                                                 volPtr->depth  / (float)volPtr->width,
    1837                                                 1.0f);
    1838                                 NanoVis::flowVisRenderer->activateVectorField(vf_name);
    1839 
    1840                                 //////////////////////////////////
    1841                                 // ADD Particle Injection Plane1
    1842                                 NanoVis::flowVisRenderer->addPlane(vf_name, plane_name1);
    1843                                 NanoVis::flowVisRenderer->setPlaneAxis(vf_name, plane_name1, 0);
    1844                                 NanoVis::flowVisRenderer->setPlanePos(vf_name, plane_name1, 0.9);
    1845                                 NanoVis::flowVisRenderer->setParticleColor(vf_name, plane_name1, color1);
    1846                                 // ADD Particle Injection Plane2
    1847                                 NanoVis::flowVisRenderer->addPlane(vf_name, plane_name2);
    1848                                 NanoVis::flowVisRenderer->setPlaneAxis(vf_name, plane_name2, 0);
    1849                                 NanoVis::flowVisRenderer->setPlanePos(vf_name, plane_name2, 0.2);
    1850                                 NanoVis::flowVisRenderer->setParticleColor(vf_name, plane_name2, color2);
    1851                                 NanoVis::flowVisRenderer->initialize(vf_name);
    1852 
    1853                                 NanoVis::flowVisRenderer->activatePlane(vf_name, plane_name1);
    1854                                 NanoVis::flowVisRenderer->activatePlane(vf_name, plane_name2);
    1855        
    1856                         NanoVis::licRenderer->setVectorField(volPtr->id,
     1807void addVectorField(const char* filename, const char* vf_name,
     1808                    const char* plane_name1, const char* plane_name2,
     1809                    const Vector4& color1, const Vector4& color2)
     1810{
     1811    Rappture::Outcome result;
     1812    std::ifstream fdata;
     1813    fdata.open(filename, std::ios::in);
     1814   
     1815    int n = NanoVis::n_volumes;
     1816    //fdata.write(buf.bytes(),buf.size());
     1817    if (load_vector_stream2(result, n, fdata)) {
     1818        Volume *volPtr = NanoVis::volume[n];
     1819        if (volPtr != NULL) {
     1820            volPtr->set_n_slice(256-n);
     1821            // volPtr->set_n_slice(512-n);
     1822            volPtr->disable_cutplane(0);
     1823            volPtr->disable_cutplane(1);
     1824            volPtr->disable_cutplane(2);
     1825           
     1826            NanoVis::vol_renderer->add_volume(volPtr,
     1827                                              NanoVis::get_transfunc("default"));
     1828            float dx0 = -0.5;
     1829            float dy0 = -0.5*volPtr->height/volPtr->width;
     1830            float dz0 = -0.5*volPtr->depth/volPtr->width;
     1831            volPtr->move(Vector3(dx0, dy0, dz0));
     1832            //volPtr->enable_data();
     1833            volPtr->disable_data();
     1834            NanoVis::flowVisRenderer->addVectorField(vf_name, volPtr,
     1835                *(volPtr->get_location()),
     1836                1.0f,
     1837                volPtr->height / (float)volPtr->width,
     1838                volPtr->depth  / (float)volPtr->width,
     1839                1.0f);
     1840            NanoVis::flowVisRenderer->activateVectorField(vf_name);
     1841           
     1842            //////////////////////////////////
     1843            // ADD Particle Injection Plane1
     1844            NanoVis::flowVisRenderer->addPlane(vf_name, plane_name1);
     1845            NanoVis::flowVisRenderer->setPlaneAxis(vf_name, plane_name1, 0);
     1846            NanoVis::flowVisRenderer->setPlanePos(vf_name, plane_name1, 0.9);
     1847            NanoVis::flowVisRenderer->setParticleColor(vf_name, plane_name1, color1);
     1848            // ADD Particle Injection Plane2
     1849            NanoVis::flowVisRenderer->addPlane(vf_name, plane_name2);
     1850            NanoVis::flowVisRenderer->setPlaneAxis(vf_name, plane_name2, 0);
     1851            NanoVis::flowVisRenderer->setPlanePos(vf_name, plane_name2, 0.2);
     1852            NanoVis::flowVisRenderer->setParticleColor(vf_name, plane_name2, color2);
     1853            NanoVis::flowVisRenderer->initialize(vf_name);
     1854           
     1855            NanoVis::flowVisRenderer->activatePlane(vf_name, plane_name1);
     1856            NanoVis::flowVisRenderer->activatePlane(vf_name, plane_name2);
     1857           
     1858            NanoVis::licRenderer->setVectorField(volPtr->id,
    18571859                                *(volPtr->get_location()),
    18581860                                1.0f / volPtr->aspect_ratio_width,
     
    18601862                                1.0f / volPtr->aspect_ratio_depth,
    18611863                                volPtr->wAxis.max());
    1862                 }
    18631864        }
    1864         //NanoVis::initParticle();
     1865    }
     1866    //NanoVis::initParticle();
    18651867}
    18661868#endif
Note: See TracChangeset for help on using the changeset viewer.