Ignore:
Timestamp:
May 14, 2009 10:18:44 PM (15 years ago)
Author:
gah
Message:

Fixes for flow visualization command structure

Location:
trunk/packages/vizservers/nanovis
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/packages/vizservers/nanovis/Command.cpp

    r1431 r1434  
    689689    Rappture::Outcome err;
    690690    unsigned int flags;
    691     flags = RPENC_HDR;
     691    flags = RPENC_Z|RPENC_B64|RPENC_HDR;
    692692    if (!Rappture::encoding::decode(err, buf, flags)) {
    693693        printf("ERROR -- DECODING\n");
    … …  
    12341234        return TCL_ERROR;
    12351235    }
    1236 
     1236    const char *tag;
     1237    tag = Tcl_GetString(objv[4]);
    12371238    Rappture::Buffer buf;
    12381239    if (GetDataStream(interp, buf, nbytes) != TCL_OK) {
    … …  
    13171318        }
    13181319    } else {
    1319 
     1320#ifdef notdef
     1321        Rappture::Unirect3d *dataPtr;
     1322
     1323        dataPtr = new Rappture::Unirect3d(1);
     1324        if (!dataPtr->ImportDx(result, 1, buf.size(), (char *)buf.bytes())) {
     1325            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     1326            delete dataPtr;
     1327            return TCL_ERROR;
     1328        }
     1329#if !ISO_TEST
     1330        dataPtr->Resample(context, 30);
     1331#endif
     1332        Volume *volPtr;
     1333        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, vmin, vmax,
     1334                                  nzero_min);
     1335   
     1336    volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMin() + (nx * dx));
     1337    volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMin() + (ny * dy));
     1338    volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMin() + (nz * dz));
     1339    volPtr->wAxis.SetRange(vmin, vmax);
     1340    volPtr->update_pending = true;
     1341
     1342        flowPtr->SetData(dataPtr);
     1343#endif
    13201344        printf("OpenDX loading...\n");
    13211345        fflush(stdout);
    … …  
    13671391        volPtr = NanoVis::volume[n];
    13681392        // FIXME: strlen(info) is the return value of sprintf
    1369         sprintf(info, "nv>data id %d min %g max %g vmin %g vmax %g\n",
    1370                 n, volPtr->wAxis.min(), volPtr->wAxis.max(),
     1393        sprintf(info, "nv>data tag %s id %d min %g max %g vmin %g vmax %g\n",
     1394                tag, n, volPtr->wAxis.min(), volPtr->wAxis.max(),
    13711395                Volume::valueMin, Volume::valueMax);
    13721396        nWritten  = write(0, info, strlen(info));
    … …  
    14031427
    14041428static Rappture::CmdSpec volumeDataOps[] = {
    1405     {"follows",   1, VolumeDataFollowsOp, 4, 4, "size",},
     1429    {"follows",   1, VolumeDataFollowsOp, 5, 5, "size tag",},
    14061430    {"state",     1, VolumeDataStateOp,   4, 0, "bool ?indices?",},
    14071431};

  • trunk/packages/vizservers/nanovis/FlowCmd.cpp

    r1431 r1434  
    338338}
    339339
    340 
    341 #ifdef notdef
    342 int
    343 NanoVis::InitVectorField(Tcl_Interp *interp)
    344 {
    345     if (flowVisRenderer == NULL) {
    346         Tcl_AppendResult(interp, "flowvis renderer is NULL", (char *)NULL);
    347         return TCL_ERROR;
    348     }
    349     if (licRenderer == NULL) {
    350         Tcl_AppendResult(interp, "LIC renderer is NULL", (char *)NULL);
    351         return TCL_ERROR;
    352     }
    353     _fieldPtr->setVectorField(_volPtr->id, *(_volPtr->get_location()),
    354         1.0f, _volPtr->height / (float)_volPtr->width,
    355         _volPtr->depth  / (float)_volPtr->width,
    356         _volPtr->wAxis.max());
    357 
    358     licRenderer->make_patterns();
    359     licRenderer->setVectorField(
    360         _volPtr->id,                    /* Texture ID */
    361         *(_volPtr->get_location()),     /* Origin */
    362         1.0f / volPtr->aspect_ratio_width, /* X-axis scale. */
    363         1.0f / volPtr->aspect_ratio_height, /* Y-axis scale. */
    364         1.0f / volPtr->aspect_ratio_depth, /* Z-axis scale. */
    365         volPtr->wAxis.max());           /* Maximum ???? */
    366 
    367     licRenderer->set_offset(lic_slice_z);
    368     return TCL_OK;
    369 }
    370 #endif
    371 
    372340int
    373341FlowCmd::CreateParticles(Tcl_Interp *interp, Tcl_Obj *objPtr)
    … …  
    499467    }
    500468    return (FlowBox *)Tcl_GetHashValue(iterPtr->hashPtr);
    501 }
    502 
    503 void
    504 FlowCmd::GetMagRange(double &min_mag, double &max_mag)
    505 {
    506     const float *values = _dataPtr->values();
    507     size_t nValues = _dataPtr->nValues();
    508     max_mag = -1e21, min_mag = 1e21;
    509     for (size_t i = 0; i < nValues; i += 3) {
    510         double vx, vy, vz, vm;
    511 
    512         vx = values[i];
    513         vy = values[i+1];
    514         vz = values[i+2];
    515                    
    516         vm = sqrt(vx*vx + vy*vy + vz*vz);
    517         if (vm > max_mag) {
    518             max_mag = vm;
    519         }
    520         if (vm < min_mag) {
    521             min_mag = vm;
    522         }
    523     }
    524469}
    525470
    … …  
    712657{
    713658    Rappture::Outcome result;
    714 
     659   
    715660    const char *fileName;
    716661    fileName = Tcl_GetString(objv[3]);
    717662    Trace("Flow loading data from file %s\n", fileName);
    718663
    719     int extents;
    720     if (Tcl_GetIntFromObj(interp, objv[4], &extents) != TCL_OK) {
     664    int nComponents;
     665    if (Tcl_GetIntFromObj(interp, objv[4], &nComponents) != TCL_OK) {
    721666        return TCL_ERROR;
    722667    }
    723     if ((extents < 1) || (extents > 4)) {
    724         Tcl_AppendResult(interp, "bad extents value \"", Tcl_GetString(objv[4]),
    725                          "\"", (char *)NULL);
     668    if ((nComponents < 1) || (nComponents > 4)) {
     669        Tcl_AppendResult(interp, "bad # of components \"",
     670                         Tcl_GetString(objv[4]), "\"", (char *)NULL);
    726671        return TCL_ERROR;
    727672    }
    … …  
    737682        Rappture::Unirect3d *dataPtr;
    738683
    739         dataPtr = new Rappture::Unirect3d(extents);
    740         if (!dataPtr->ReadVectorDataFromDx(result, buf.size(),
     684        dataPtr = new Rappture::Unirect3d(nComponents);
     685        if (!dataPtr->ImportDx(result, nComponents, buf.size(),
    741686                (char *)buf.bytes())) {
    742687            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
    … …  
    754699            return TCL_ERROR;
    755700        }
    756         dataPtr = new Rappture::Unirect3d(extents);
     701        dataPtr = new Rappture::Unirect3d(nComponents);
    757702        cmdInfo.objClientData = (ClientData)dataPtr;   
    758703        Tcl_SetCommandInfo(interp, "unirect3d", &cmdInfo);
    … …  
    769714        Rappture::Unirect3d *dataPtr;
    770715
    771         dataPtr = new Rappture::Unirect3d(extents);
    772         if (!dataPtr->ReadVectorDataFromDx(result, buf.size(),
    773                                            (char *)buf.bytes())) {
     716        dataPtr = new Rappture::Unirect3d(nComponents);
     717        if (!dataPtr->ImportDx(result, nComponents, buf.size(),
     718                (char *)buf.bytes())) {
    774719            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
    775720            delete dataPtr;
    … …  
    783728
    784729/*
    785  * $flow data follows nbytes extents
     730 * $flow data follows nbytes nComponents
    786731 */
    787732static int
    … …  
    804749        return TCL_ERROR;
    805750    }
    806     int extents;
    807     if (Tcl_GetIntFromObj(interp, objv[4], &extents) != TCL_OK) {
    808         Trace("Bad extents \"%s\"\n", Tcl_GetString(objv[4]));
     751    int nComponents;
     752    if (Tcl_GetIntFromObj(interp, objv[4], &nComponents) != TCL_OK) {
     753        Trace("Bad # of components \"%s\"\n", Tcl_GetString(objv[4]));
    809754        return TCL_ERROR;
    810755    }
    811     if (extents <= 0) {
    812         Tcl_AppendResult(interp, "bad extents request \"",
     756    if (nComponents <= 0) {
     757        Tcl_AppendResult(interp, "bad # of components request \"",
    813758                Tcl_GetString(objv[4]), "\" for \"data follows\"", (char *)NULL);
    814         Trace("Bad extents %d\n", extents);
     759        Trace("Bad # of components %d\n", nComponents);
    815760        return TCL_ERROR;
    816761    }
    817762    Rappture::Buffer buf;
    818     Trace("Flow Data Loading %d %d\n", nBytes, extents);
     763    Trace("Flow Data Loading %d %d\n", nBytes, nComponents);
    819764    if (GetDataStream(interp, buf, nBytes) != TCL_OK) {
    820765        return TCL_ERROR;
    … …  
    824769        Rappture::Unirect3d *dataPtr;
    825770
    826         dataPtr = new Rappture::Unirect3d(extents);
    827         if (!dataPtr->ReadVectorDataFromDx(result, buf.size(),
     771        dataPtr = new Rappture::Unirect3d(nComponents);
     772        if (!dataPtr->ImportDx(result, nComponents, buf.size(),
    828773                (char *)buf.bytes())) {
    829774            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
    … …  
    839784        /* Set the clientdata field of the unirect3d command to contain
    840785         * the local data structure. */
    841         dataPtr = new Rappture::Unirect3d(extents);
     786        dataPtr = new Rappture::Unirect3d(nComponents);
    842787        if (!Tcl_GetCommandInfo(interp, "unirect3d", &cmdInfo)) {
    843788            return TCL_ERROR;
    … …  
    859804        Rappture::Unirect3d *dataPtr;
    860805
    861         dataPtr = new Rappture::Unirect3d(extents);
    862         if (!dataPtr->ReadVectorDataFromDx(result, buf.size(),
    863                                            (char *)buf.bytes())) {
     806        dataPtr = new Rappture::Unirect3d(nComponents);
     807        if (!dataPtr->ImportDx(result, nComponents, buf.size(),
     808                               (char *)buf.bytes())) {
    864809            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
    865810            delete dataPtr;
    … …  
    873818        size_t length;
    874819
    875         length = sprintf(info, "nv>data id 0 name %s min 0 max 1 vmin 0 vmax 1\n",
    876                 flowPtr->name());
     820        length = sprintf(info, "nv>data tag %s id 0 min %g max %g vmin %g vmax %g\n",
     821                         flowPtr->name(), NanoVis::magMin,
     822                         NanoVis::magMax, NanoVis::xMin, NanoVis::xMax);
    877823        nWritten  = write(0, info, length);
    878824        assert(nWritten == (ssize_t)strlen(info));
    … …  
    883829
    884830static Rappture::CmdSpec flowDataOps[] = {
    885     {"file",    2, FlowDataFileOp,    5, 5, "fileName extents",},
    886     {"follows", 2, FlowDataFollowsOp, 5, 5, "size extents",},
     831    {"file",    2, FlowDataFileOp,    5, 5, "fileName nComponents",},
     832    {"follows", 2, FlowDataFollowsOp, 5, 5, "size nComponents",},
    887833};
    888834static int nFlowDataOps = NumCmdSpecs(flowDataOps);
    … …  
    1034980    for (flowPtr = FirstFlow(&iter); flowPtr != NULL;
    1035981         flowPtr = NextFlow(&iter)) {
    1036         double minMag, maxMag;
     982        double min, max;
    1037983        if (!flowPtr->isDataLoaded()) {
    1038984            continue;
    1039985        }
    1040         flowPtr->GetMagRange(minMag, maxMag);
    1041         if (minMag < NanoVis::magMin) {
    1042             NanoVis::magMin = minMag;
    1043         }
    1044         if (maxMag > NanoVis::magMax) {
    1045             NanoVis::magMax = maxMag;
    1046         }
    1047986        Rappture::Unirect3d *dataPtr;
    1048987        dataPtr = flowPtr->GetData();
    1049         if (dataPtr->xMin() < NanoVis::xMin) {
    1050             NanoVis::xMin = dataPtr->xMin();
    1051         }
    1052         if (dataPtr->yMin() < NanoVis::yMin) {
    1053             NanoVis::yMin = dataPtr->yMin();
    1054         }
    1055         if (dataPtr->zMin() < NanoVis::zMin) {
    1056             NanoVis::zMin = dataPtr->zMin();
    1057         }
    1058         if (dataPtr->xMax() > NanoVis::xMax) {
    1059             NanoVis::xMax = dataPtr->xMax();
    1060         }
    1061         if (dataPtr->yMax() > NanoVis::yMax) {
    1062             NanoVis::yMax = dataPtr->yMax();
    1063         }
    1064         if (dataPtr->zMax() > NanoVis::zMax) {
    1065             NanoVis::zMax = dataPtr->zMax();
     988        min = dataPtr->magMin();
     989        max = dataPtr->magMax();
     990        if (min < magMin) {
     991            magMin = min;
     992        }
     993        if (max > magMax) {
     994            magMax = max;
     995        }
     996        if (dataPtr->xMin() < xMin) {
     997            xMin = dataPtr->xMin();
     998        }
     999        if (dataPtr->yMin() < yMin) {
     1000            yMin = dataPtr->yMin();
     1001        }
     1002        if (dataPtr->zMin() < zMin) {
     1003            zMin = dataPtr->zMin();
     1004        }
     1005        if (dataPtr->xMax() > xMax) {
     1006            xMax = dataPtr->xMax();
     1007        }
     1008        if (dataPtr->yMax() > yMax) {
     1009            yMax = dataPtr->yMax();
     1010        }
     1011        if (dataPtr->zMax() > zMax) {
     1012            zMax = dataPtr->zMax();
    10661013        }
    10671014    }
    … …  
    10841031            return false;
    10851032        }
    1086         NanoVis::licRenderer->set_offset(flowPtr->GetRelativePosition());
    1087     }
     1033        licRenderer->set_offset(flowPtr->GetRelativePosition());
     1034    }
     1035    AdvectFlows();
    10881036    return true;
    10891037}
    … …  
    10921040NanoVis::RenderFlows(void)
    10931041{
    1094 #ifdef notdef
    1095     if (!licRenderer->active()) {
    1096         licRenderer->active(true);
    1097     }
    1098 #endif
    10991042    FlowCmd *flowPtr;
    11001043    FlowIterator iter;
    … …  
    11111054NanoVis::ResetFlows(void)
    11121055{
    1113 #ifdef notdef
    1114     if (!licRenderer->active()) {
    1115         licRenderer->active(true);
    1116     }
    1117 #endif
    11181056    FlowCmd *flowPtr;
    11191057    FlowIterator iter;
    … …  
    11291067NanoVis::AdvectFlows(void)
    11301068{
    1131 #ifdef notdef
    1132     if (!licRenderer->active()) {
    1133         licRenderer->active(true);
    1134     }
    1135 #endif
    11361069    FlowCmd *flowPtr;
    11371070    FlowIterator iter;
    … …  
    18211754{
    18221755    assert(NanoVis::licRenderer != NULL);
    1823 #ifdef notdef
    1824     if (!NanoVis::licRenderer->active()) {
    1825         NanoVis::licRenderer->active(true);
    1826     }
    1827 #endif
    18281756    if (NanoVis::flags & NanoVis::MAP_FLOWS) {
    18291757        NanoVis::MapFlows();
    … …  
    18821810        return TCL_ERROR;
    18831811    }
    1884 #ifdef notdef
    1885     NanoVis::licRenderer->active(true);
    1886 #endif
    18871812    // Save the old dimensions of the offscreen buffer.
    18881813    int oldWidth, oldHeight;

  • trunk/packages/vizservers/nanovis/FlowCmd.h

    r1431 r1434  
    1616struct FlowParticlesValues {
    1717    int isHidden;                       /* Indicates if particle injection
    18                                          * plance is active or not. */
     18                                         * plane is active or not. */
    1919    FlowPosition position;              /* Position on axis of particle
    2020                                         * plane */
    … …  
    285285        NanoVis::licRenderer->active(_sv.sliceVisible);
    286286    }
    287     void GetMagRange(double &min_mag, double &max_mag);
    288 
    289287    void SetVectorField(NvVectorField *fieldPtr) {
    290288        DeleteVectorField();

  • trunk/packages/vizservers/nanovis/Unirect.cpp

    r1431 r1434  
    416416
    417417bool
    418 Rappture::Unirect3d::ReadVectorDataFromDx(Rappture::Outcome &result,
     418Rappture::Unirect3d::ImportDx(Rappture::Outcome &result, int nComponents,
    419419        size_t length, char *string)
    420420{
    … …  
    486486    _yMax = _yMin + dy * _yNum;
    487487    _zMax = _zMin + dz * _zNum;
     488    _nComponents = nComponents;
     489
    488490    if (_values != NULL) {
    489491        delete [] _values;
    … …  
    617619}
    618620
     621
     622void
     623Rappture::Unirect3d::GetVectorRange(void)
     624{
     625    assert(_nComponents == 3);
     626    _magMax = -DBL_MAX, _magMin = DBL_MAX;
     627    size_t i;
     628    for (i = 0; i < _nValues; i += _nComponents) {
     629        double vx, vy, vz, vm;
     630
     631        vx = _values[i];
     632        vy = _values[i+1];
     633        vz = _values[i+2];
     634                   
     635        vm = sqrt(vx*vx + vy*vy + vz*vz);
     636        if (vm > _magMax) {
     637            _magMax = vm;
     638        }
     639        if (vm < _magMin) {
     640            _magMin = vm;
     641        }
     642    }
     643}

  • trunk/packages/vizservers/nanovis/Unirect.h

    r1429 r1434  
    1414    float _yValueMin, _yValueMax;
    1515    float _zValueMin, _zValueMax;
     16    double _magMin, _magMax;            /* Range of magnitudes of vector
     17                                         * data. */
    1618    char *_xUnits;
    1719    char *_yUnits;
    … …  
    2123    float *_values;
    2224    bool _initialized;
     25    void GetVectorRange(void);
    2326
    2427public:
    … …  
    3942        _xUnits = _yUnits = _zUnits = _vUnits = NULL;
    4043        _nComponents = nComponents;
     44        _magMin = DBL_MAX;
     45        _magMax = -DBL_MAX;
    4146    }
    4247    ~Unirect3d(void) {
    … …  
    7075        _zMin = zMin;
    7176        _zNum = zNum;
     77        _magMin = DBL_MAX;
     78        _magMax = -DBL_MAX;
    7279        _nValues = nValues;
    7380        _values = values;
    … …  
    138145        return _values;
    139146    }
     147    double magMin(void) {
     148        if (_magMin == DBL_MAX) {
     149            GetVectorRange();
     150        }
     151        return _magMin;
     152    }
     153    double magMax(void) {
     154        if (_magMax == -DBL_MAX) {
     155            GetVectorRange();
     156        }
     157        return _magMax;
     158    }
    140159    const float *SaveValues(void) {
    141160        float *values;
    … …  
    150169    int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
    151170
    152     bool ReadVectorDataFromDx(Rappture::Outcome &result, size_t length,
    153         char *string);
     171    bool ImportDx(Rappture::Outcome &result, int nComponents,
     172                  size_t length, char *string);
    154173    bool Resample(Rappture::Outcome &context, int nSamples = 30);
    155174    bool isInitialized(void) {

  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r1429 r1434  
    4444
    4545#define  _LOCAL_ZINC_TEST_ 0
    46 
    47 static INLINE char *
    48 skipspaces(char *string)
    49 {
    50     while (isspace(*string)) {
    51         string++;
    52     }
    53     return string;
    54 }
    55 
    56 static INLINE char *
    57 getline(char **stringPtr, char *endPtr)
    58 {
    59     char *line, *p;
    60 
    61     line = skipspaces(*stringPtr);
    62     for (p = line; p < endPtr; p++) {
    63         if (*p == '\n') {
    64             *p++ = '\0';
    65             *stringPtr = p;
    66             return line;
    67         }
    68     }
    69     *stringPtr = p;
    70     return line;
    71 }
    72 
    73 Rappture::Unirect3d *
    74 ReadDxVectorFieldData(Rappture::Outcome &result, size_t length, char *string)
    75 {
    76     int nx, ny, nz, npts;
    77     double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
    78     char *p, *endPtr;
    79 
    80 
    81     dx = dy = dz = 0.0;         // Suppress compiler warning.
    82     x0 = y0 = z0 = 0.0;         // May not have an origin line.
    83     for (p = string, endPtr = p + length; p < endPtr; /*empty*/) {
    84         char *line;
    85 
    86         line = getline(&p, endPtr);
    87         if (line == endPtr) {
    88             break;
    89         }
    90         if ((line[0] == '#') || (line == '\0')) {
    91             continue;           // Skip blank or comment lines.
    92         }
    93         if (sscanf(line, "object %*d class gridpositions counts %d %d %d",
    94                    &nx, &ny, &nz) == 3) {
    95             printf("w:%d h:%d d:%d\n", nx, ny, nz);
    96             // found grid size
    97         } else if (sscanf(line, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
    98             // found origin
    99         } else if (sscanf(line, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
    100             // found one of the delta lines
    101             if (ddx != 0.0) {
    102                 dx = ddx;
    103             } else if (ddy != 0.0) {
    104                 dy = ddy;
    105             } else if (ddz != 0.0) {
    106                 dz = ddz;
    107             }
    108         } else if (sscanf(line, "object %*d class array type %*s shape 3"
    109                 " rank 1 items %d data follows", &npts) == 1) {
    110             printf("point %d\n", npts);
    111             if (npts != nx*ny*nz) {
    112                 result.addError("inconsistent data: expected %d points"
    113                                 " but found %d points", nx*ny*nz, npts);
    114                 return NULL;
    115             }
    116             break;
    117         } else if (sscanf(line, "object %*d class array type %*s rank 0"
    118                 " times %d data follows", &npts) == 1) {
    119             if (npts != nx*ny*nz) {
    120                 result.addError("inconsistent data: expected %d points"
    121                                 " but found %d points", nx*ny*nz, npts);
    122                 return NULL;
    123             }
    124             break;
    125         }
    126     }
    127     if (npts != nx*ny*nz) {
    128         result.addError("inconsistent data: expected %d points"
    129                         " but found %d points", nx*ny*nz, npts);
    130         return NULL;
    131     }
    132     float *values = new float[npts];
    133     int nValues = 0;
    134     for (int ix=0; ix < nx; ix++) {
    135         for (int iy=0; iy < ny; iy++) {
    136             for (int iz=0; iz < nz; iz++) {
    137                 char *line;
    138                 if ((p == endPtr) || (nValues > npts)) {
    139                     break;
    140                 }
    141                 line = getline(&p, endPtr);
    142                 if ((line[0] == '#') || (line[0] == '\0')) {
    143                     continue;   // Skip blank or comment lines.
    144                 }
    145                 double vx, vy, vz;
    146                 if (sscanf(line, "%lg %lg %lg", &vx, &vy, &vz) == 3) {
    147                     int nindex = (iz*nx*ny + iy*nx + ix) * 3;
    148                     values[nindex] = vx;
    149                     values[nindex+1] = vy;
    150                     values[nindex+2] = vz;
    151                     nValues++;
    152                 }
    153             }
    154         }
    155     }
    156     // make sure that we read all of the expected points
    157     if (nValues != npts) {
    158         result.addError("inconsistent data: expected %d points"
    159                         " but found %d points", npts, nValues);
    160         delete values;
    161         return NULL;
    162     }
    163     return new Rappture::Unirect3d(x0, x0 + dx * nx, nx, y0, y0 + dy * ny, ny,
    164                                    z0, z0 + dz * nz, nz, nValues, values, 3);
    165 }
    166 
    167 
    168 #ifdef notdef
    169 /*
    170  * Load a 3D vector field from a dx-format file
    171  */
    172 bool
    173 load_vector_stream2(Rappture::Outcome &result, int ivol, size_t length,
    174                     char *string)
    175 {
    176     Rappture::Unirect3d *dataPtr;
    177     dataPtr = ReadDxVectorFieldData(result, length, string);
    178     if (dataPtr == NULL) {
    179         return false;
    180     }
    181     Vector3 physicalMin;
    182     Vector3 physicalMax;
    183 
    184     physicalMin.set(dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
    185     physicalMax.set(dataPtr->xMax(), dataPtr->yMax(), dataPtr->zMax());
    186 
    187     double max_mag = -DBL_MAX, min_mag = DBL_MAX;
    188     float *values = dataPtr->values();
    189     for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
    190         for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
    191             for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
    192                 double vx, vy, vz, vm;
    193                 vx = values[0];
    194                 vy = values[1];
    195                 vz = values[2];
    196                 vm = sqrt(vx*vx + vy*vy + vz*vz);
    197                 if (vm > max_mag) {
    198                     max_mag = vm;
    199                 }
    200                 if (vm < min_mag) {
    201                     min_mag = vm;
    202                 }
    203                 values += 3;
    204             }
    205         }
    206     }
    207    
    208     float *data = new float[4*dataPtr->nValues()];
    209     memset(data, 0, sizeof(float) * 4 * dataPtr->nValues());
    210     fprintf(stderr, "generating %dx%dx%d = %d points\n",
    211             dataPtr->xNum(), dataPtr->yNum(), dataPtr->zNum(),
    212             dataPtr->nValues());
    213 
    214     float *destPtr = data;
    215     float *srcPtr = dataPtr->values();
    216     for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
    217         for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
    218             for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
    219                 double vx, vy, vz, vm;
    220                 vx = values[0];
    221                 vy = values[1];
    222                 vz = values[2];
    223                 vm = sqrt(vx*vx + vy*vy + vz*vz);
    224                 destPtr[0] = vm / max_mag;
    225                 destPtr[1] = vx /(2.0*max_mag) + 0.5;
    226                 destPtr[2] = vy /(2.0*max_mag) + 0.5;
    227                 destPtr[3] = vz /(2.0*max_mag) + 0.5;
    228                 srcPtr += 3;
    229                 destPtr += 4;
    230             }
    231         }
    232     }
    233    
    234     Volume *volPtr;
    235     volPtr = NanoVis::load_volume(ivol, dataPtr->xNum(), dataPtr->yNum(),
    236                 dataPtr->zNum(), 4, data, min_mag, max_mag, 0);
    237     volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMax());
    238     volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMax());
    239     volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMax());
    240     volPtr->wAxis.SetRange(min_mag, max_mag);
    241     volPtr->update_pending = true;
    242     volPtr->setPhysicalBBox(physicalMin, physicalMax);
    243     delete dataPtr;
    244     delete data;
    245     return true;
    246 }
    247 
    248 bool
    249 load_vector_stream(Rappture::Outcome result, int index, size_t length,
    250                     char *string)
    251 {
    252     Rappture::Unirect3d *dataPtr;
    253     dataPtr = ReadDxVectorFieldData(result, length, string);
    254     if (dataPtr == NULL) {
    255         return false;
    256     }
    257     Vector3 physicalMin;
    258     Vector3 physicalMax;
    259 
    260     physicalMin.set(dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
    261     physicalMax.set(dataPtr->xMax(), dataPtr->yMax(), dataPtr->zMax());
    262 
    263     Rappture::Mesh1D xgrid(dataPtr->xMin(), dataPtr->yMin(), dataPtr->xNum());
    264     Rappture::Mesh1D ygrid(dataPtr->yMin(), dataPtr->yMax(), dataPtr->yNum());
    265     Rappture::Mesh1D zgrid(dataPtr->zMin(), dataPtr->zMax(), dataPtr->zNum());
    266     Rappture::FieldRect3D xfield(xgrid, ygrid, zgrid);
    267     Rappture::FieldRect3D yfield(xgrid, ygrid, zgrid);
    268     Rappture::FieldRect3D zfield(xgrid, ygrid, zgrid);
    269    
    270     float *values = dataPtr->values();
    271     size_t npts = 0;
    272     for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
    273         for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
    274             for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
    275                 xfield.define(npts, values[0]);
    276                 yfield.define(npts, values[1]);
    277                 zfield.define(npts, values[2]);
    278                 npts++;
    279                 values += 3;
    280             }
    281         }
    282     }
    283 
    284     double dx, dy, dz;
    285     // figure out a good mesh spacing
    286     int nsample = 30;
    287     dx = xfield.rangeMax(Rappture::xaxis) - xfield.rangeMin(Rappture::xaxis);
    288     dy = xfield.rangeMax(Rappture::yaxis) - xfield.rangeMin(Rappture::yaxis);
    289     dz = xfield.rangeMax(Rappture::zaxis) - xfield.rangeMin(Rappture::zaxis);
    290     double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
    291 
    292     printf("dx:%lf dy:%lf dz:%lf dmin:%lf\n", dx, dy, dz, dmin);
    293 
    294     size_t nx, ny, nz;
    295     nx = (int)ceil(dx/dmin);
    296     ny = (int)ceil(dy/dmin);
    297     nz = (int)ceil(dz/dmin);
    298    
    299 #ifndef NV40
    300     // must be an even power of 2 for older cards
    301     nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    302     ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    303     nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    304 #endif
    305    
    306     float *data = new float[4*nx*ny*nz];
    307     memset(data, 0, sizeof(float) * 4 * nx * ny * nz);
    308    
    309     std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
    310    
    311     // generate the uniformly sampled data that we need for a volume
    312     double vmin = 1e21;
    313     double vmax = -1e21;
    314     double nzero_min = 0.0;
    315     size_t ngen = 0;
    316     for (size_t iz=0; iz < nz; iz++) {
    317         double zval = dataPtr->zMin() + iz*dmin;
    318         for (size_t iy=0; iy < ny; iy++) {
    319             double yval = dataPtr->yMin() + iy*dmin;
    320             for (size_t ix=0; ix < nx; ix++) {
    321                 double xval = dataPtr->xMin() + ix*dmin;
    322                 double vx, vy, vz;
    323 
    324                 vx = xfield.value(xval,yval,zval);
    325                 vy = yfield.value(xval,yval,zval);
    326                 vz = zfield.value(xval,yval,zval);
    327                
    328                 double vm;
    329                 vm = sqrt(vx*vx + vy*vy + vz*vz);
    330                 if (vm < vmin) {
    331                     vmin = vm;
    332                 } else if (vm > vmax) {
    333                     vmax = vm;
    334                 }
    335                 if ((vm != 0.0f) && (vm < nzero_min)) {
    336                     nzero_min = vm;
    337                 }
    338                 data[ngen++] = vm;
    339                 data[ngen++] = vx;
    340                 data[ngen++] = vy;
    341                 data[ngen++] = vz;
    342             }
    343         }
    344     }
    345    
    346     ngen = 0;
    347     // scale should be accounted.
    348     for (ngen=0; ngen < npts; /*empty*/) {
    349         data[ngen] = data[ngen] / vmax; ++ngen;
    350         data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
    351         data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
    352         data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
    353     }
    354     Volume *volPtr;
    355     volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, vmin, vmax,
    356                                   nzero_min);
    357    
    358     volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMin() + (nx * dx));
    359     volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMin() + (ny * dy));
    360     volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMin() + (nz * dz));
    361     volPtr->wAxis.SetRange(vmin, vmax);
    362     volPtr->update_pending = true;
    363     delete [] data;
    364     return true;
    365 }
    366 #endif
    36746
    36847/* Load a 3D volume from a dx-format file
    … …  
    963642#endif
    964643       
     644#ifdef notdef
    965645        for (int i=0; i<nx*ny*nz; i++) {
    966646            fprintf(stderr,"enddata[%i] = %lg\n",i,data[i]);
    967647            fflush(stderr);
    968648        }
    969        
     649#endif 
    970650        fprintf(stdout,"End Data Stats index = %i\n",index);
    971651        fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);

  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r1431 r1434  
    16741674    if (flags & MAP_FLOWS) {
    16751675        MapFlows();
     1676        grid->xAxis.SetScale(xMin, xMax);
     1677        grid->yAxis.SetScale(yMin, yMax);
     1678        grid->zAxis.SetScale(zMin, zMax);
    16761679    }
    16771680    //assert(glGetError()==0);
    … …  
    20772080{
    20782081
    2079     if ((NanoVis::licRenderer != NULL) &&
    2080         (NanoVis::licRenderer->active())) {
     2082#ifdef notdef
     2083    if ((NanoVis::licRenderer != NULL) && (NanoVis::licRenderer->active())) {
    20812084        NanoVis::licRenderer->convolve();
    20822085    }
    2083 
    2084     if ((NanoVis::flowVisRenderer != NULL) &&
    2085         (NanoVis::flowVisRenderer->active())) {
     2086#else
     2087    if (NanoVis::licRenderer != NULL) {
     2088        NanoVis::licRenderer->convolve();
     2089    }
     2090#endif
     2091
     2092    if ((NanoVis::flowVisRenderer != NULL) && (NanoVis::flowVisRenderer->active())) {
    20862093        NanoVis::flowVisRenderer->advect();
    20872094    }
Note: See TracChangeset for help on using the changeset viewer.