Ignore:
Timestamp:
May 29, 2009, 1:13:42 PM (15 years ago)
Author:
vrinside
Message:

mofified a way of dealing with volumes by adding reference counts to data objects.

  • To-do : check any memory leaks for graphics objects
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1474 r1475  
    363363/*
    364364 * ----------------------------------------------------------------------
    365  * FUNCTION: GetVolumeIndex
     365 * FUNCTION: GetVolumeDataID
    366366 *
    367367 * Used internally to decode a series of volume index values and
    … …  
    375375 */
    376376static int
    377 GetVolumeIndex(Tcl_Interp *interp, Tcl_Obj *objPtr, unsigned int *indexPtr)
    378 {
    379     int index;
    380     if (Tcl_GetIntFromObj(interp, objPtr, &index) != TCL_OK) {
     377GetVolumeDataID(Tcl_Interp *interp, Tcl_Obj *objPtr, unsigned int *dataIDPtr)
     378{
     379    int volDataID;
     380    if (Tcl_GetIntFromObj(interp, objPtr, &volDataID) != TCL_OK) {
    381381        return TCL_ERROR;
    382382    }
    … …  
    386386        return TCL_ERROR;
    387387    }
     388        /*
    388389    if (index >= (int)NanoVis::volume.size()) {
    389390        Tcl_AppendResult(interp, "index \"", Tcl_GetString(objPtr),
    … …  
    391392        return TCL_ERROR;
    392393    }
    393     *indexPtr = (unsigned int)index;
     394        */
     395
     396    NanoVis::VolumeMap::iterator iter = NanoVis::volumeMap.find(volDataID);
     397    if (iter == NanoVis::volumeMap.end())
     398    {
     399        Tcl_AppendResult(interp, "dataID \"", Tcl_GetString(objPtr),
     400                     "\" is out found", (char*)NULL);
     401        return TCL_ERROR;
     402    }
     403
     404    *dataIDPtr = (unsigned int)volDataID;
    394405    return TCL_OK;
    395406}
    … …  
    411422GetVolumeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Volume **volPtrPtr)
    412423{
    413     unsigned int index;
    414     if (GetVolumeIndex(interp, objPtr, &index) != TCL_OK) {
     424    unsigned int volDataID;
     425    if (GetVolumeDataID(interp, objPtr, &volDataID) != TCL_OK) {
    415426        return TCL_ERROR;
    416427    }
    417428    Volume *vol;
    418     vol = NanoVis::volume[index];
     429    vol = NanoVis::volumeMap[volDataID];
    419430    if (vol == NULL) {
    420         Tcl_AppendResult(interp, "no volume defined for index \"",
     431        Tcl_AppendResult(interp, "no volume defined for volDataID \"",
    421432                         Tcl_GetString(objPtr), "\"", (char*)NULL);
    422433        return TCL_ERROR;
    423434    }
    424435    *volPtrPtr = vol;
     436    //printf("volume [%d] found\n", vol->getDataID());
    425437    return TCL_OK;
    426438}
    … …  
    428440/*
    429441 * ----------------------------------------------------------------------
    430  * FUNCTION: GetVolumeIndices()
     442 * FUNCTION: GetVolumeDataIDs()
    431443 *
    432444 * Used internally to decode a series of volume index values and
    … …  
    440452 */
    441453static int
    442 GetVolumeIndices(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
     454GetVolumeDataIDs(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
    443455                 vector<unsigned int>* vectorPtr)
    444456{
    445457    if (objc == 0) {
    446         for (unsigned int n = 0; n < NanoVis::volume.size(); n++) {
    447             if (NanoVis::volume[n] != NULL) {
    448                 vectorPtr->push_back(n);
    449             }
     458        NanoVis::VolumeMap::iterator iter;
     459        for (iter = NanoVis::volumeMap.begin(); iter != NanoVis::volumeMap.end(); ++iter) {
     460                if ((*iter).second != NULL) {
     461                        vectorPtr->push_back((*iter).first);
     462                }
    450463        }
    451464    } else {
     465        NanoVis::VolumeMap::iterator iter;
    452466        for (int n = 0; n < objc; n++) {
    453             unsigned int index;
    454 
    455             if (GetVolumeIndex(interp, objv[n], &index) != TCL_OK) {
     467            unsigned int volDataID;
     468
     469            if (GetVolumeDataID(interp, objv[n], &volDataID) != TCL_OK) {
    456470                return TCL_ERROR;
    457471            }
    458             if (NanoVis::volume[index] != NULL) {
    459                 vectorPtr->push_back(index);
     472
     473            iter = NanoVis::volumeMap.find(volDataID);
     474            if ((iter != NanoVis::volumeMap.end()) && ((*iter).second != 0)) {
     475                vectorPtr->push_back(volDataID);
    460476            }
    461477        }
    … …  
    482498{
    483499    if (objc == 0) {
    484         for (unsigned int n = 0; n < NanoVis::volume.size(); n++) {
    485             if (NanoVis::volume[n] != NULL) {
    486                 vectorPtr->push_back(NanoVis::volume[n]);
     500       NanoVis::VolumeMap::iterator iter;
     501        for (iter = NanoVis::volumeMap.begin(); iter != NanoVis::volumeMap.end(); ++iter) {
     502            if ((*iter).second != NULL) {
     503                vectorPtr->push_back((*iter).second);
    487504            }
    488505        }
    … …  
    11851202{
    11861203    vector<unsigned int> ivol;
    1187     if (GetVolumeIndices(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
    1188         return TCL_ERROR;
    1189     }
    1190     Trace("parsing volume index\n");
     1204    if (GetVolumeDataIDs(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
     1205        return TCL_ERROR;
     1206    }
     1207    Trace("parsing volume data identifier\n");
    11911208    vector<unsigned int>::iterator iter;
    11921209    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
    1193         Trace("index: %d\n", *iter);
    1194         NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volume[*iter], *iter);
     1210        Trace("volDataID: %d\n", *iter);
     1211        NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volumeMap[*iter], *iter);
    11951212    }
    11961213    return TCL_OK;
    … …  
    12391256        return TCL_ERROR;
    12401257    }
    1241     int n = NanoVis::n_volumes;
    12421258    char header[6];
    12431259    memcpy(header, buf.bytes(), sizeof(char) * 5);
    … …  
    12601276    printf("Checking header[%s]\n", header);
    12611277    fflush(stdout);
     1278
     1279    Volume *volPtr = 0;
     1280    int volDataID = -1;
    12621281    if (strcmp(header, "<HDR>") == 0) {
    1263         Volume* vol = NULL;
    1264 
    12651282        printf("ZincBlende stream is in\n");
    12661283        fflush(stdout);
    … …  
    12701287
    12711288#if _LOCAL_ZINC_TEST_
    1272         vol = NvZincBlendeReconstructor::getInstance()->loadFromMemory(b);
     1289        volPtr = NvZincBlendeReconstructor::getInstance()->loadFromMemory(b);
    12731290#else
    1274         vol = NvZincBlendeReconstructor::getInstance()->loadFromMemory((void*) buf.bytes());
     1291        volPtr = NvZincBlendeReconstructor::getInstance()->loadFromMemory((void*) buf.bytes());
    12751292#endif  /*_LOCAL_ZINC_TEST_*/
    1276         if (vol == NULL) {
     1293        if (volPtr == NULL) {
    12771294            Tcl_AppendResult(interp, "can't get volume instance", (char *)NULL);
    12781295            return TCL_OK;
    … …  
    12801297        printf("finish loading\n");
    12811298        fflush(stdout);
    1282         while (NanoVis::n_volumes <= n) {
    1283             NanoVis::volume.push_back((Volume*) NULL);
    1284             NanoVis::n_volumes++;
    1285         }
    1286 
    1287         if (NanoVis::volume[n] != NULL) {
    1288             delete NanoVis::volume[n];
    1289             NanoVis::volume[n] = NULL;
     1299
     1300        // INSOO
     1301        // TBD..
     1302        volDataID = NanoVis::generate_data_identifier();
     1303        NanoVis::VolumeMap::iterator iter;
     1304        iter = NanoVis::volumeMap.find(volDataID);
     1305        if (iter != NanoVis::volumeMap.end())
     1306        {
     1307            if (iter->second != NULL) {
     1308                iter->second->unref();
     1309                iter->second = 0;
     1310            }
    12901311        }
    12911312
    12921313        float dx0 = -0.5;
    1293         float dy0 = -0.5*vol->height/vol->width;
    1294         float dz0 = -0.5*vol->depth/vol->width;
    1295         vol->move(Vector3(dx0, dy0, dz0));
    1296 
    1297         NanoVis::volume[n] = vol;
     1314        float dy0 = -0.5*volPtr->height/volPtr->width;
     1315        float dz0 = -0.5*volPtr->depth/volPtr->width;
     1316        volPtr->move(Vector3(dx0, dy0, dz0));
     1317
     1318        NanoVis::volumeMap[volDataID] = volPtr;
    12981319#if __TEST_CODE__
    12991320    } else if (strcmp(header, "<FET>") == 0) {
    … …  
    13081329#endif  /*__TEST_CODE__*/
    13091330    } else if (strcmp(header, "<ODX>") == 0) {
     1331        /*
    13101332        Rappture::Outcome err;
    13111333
    … …  
    13161338            return TCL_ERROR;
    13171339        }
     1340        */
    13181341    } else {
     1342        volDataID = NanoVis::generate_data_identifier();
     1343        printf("test\n");
    13191344#ifdef notdef
    13201345        Rappture::Unirect3d *dataPtr;
    … …  
    13291354        dataPtr->Resample(context, 30);
    13301355#endif
    1331         Volume *volPtr;
    1332         volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, vmin, vmax,
     1356        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data, vmin, vmax,
    13331357                                  nzero_min);
    13341358   
    … …  
    13531377        Rappture::Outcome context;
    13541378#if ISO_TEST
    1355         result = load_volume_stream2(context, n, fdata);
     1379        result = load_volume_stream2(context, volDataID, fdata);
    13561380#else
    1357         result = load_volume_stream(context, n, fdata);
     1381        result = load_volume_stream(context, volDataID, fdata);
    13581382#endif
    13591383        if (!result) {
    … …  
    13611385            return TCL_ERROR;
    13621386        }
     1387        volPtr = NanoVis::volumeMap[volDataID];
    13631388    }
    13641389
    … …  
    13691394    // overwrite the first, so the first won't appear at all.
    13701395    //
    1371     if (NanoVis::volume[n] != NULL) {
    1372         //NanoVis::volume[n]->set_n_slice(512-n);
    1373         NanoVis::volume[n]->set_n_slice(256-n);
    1374         NanoVis::volume[n]->disable_cutplane(0);
    1375         NanoVis::volume[n]->disable_cutplane(1);
    1376         NanoVis::volume[n]->disable_cutplane(2);
    1377 
    1378         NanoVis::vol_renderer->add_volume(NanoVis::volume[n],
     1396    if (volPtr != NULL) {
     1397        //volPtr->set_n_slice(512-n);
     1398        //volPtr->set_n_slice(256-n);
     1399        volPtr->set_n_slice(256);
     1400        volPtr->disable_cutplane(0);
     1401        volPtr->disable_cutplane(1);
     1402        volPtr->disable_cutplane(2);
     1403
     1404        NanoVis::vol_renderer->add_volume(volPtr,
    13791405                                          NanoVis::get_transfunc("default"));
    1380     }
    1381 
    1382     {
    1383         Volume *volPtr;
     1406
    13841407        char info[1024];
    13851408        ssize_t nWritten;
    … …  
    13881411            NanoVis::SetVolumeRanges();
    13891412        }
    1390         volPtr = NanoVis::volume[n];
     1413
    13911414        // FIXME: strlen(info) is the return value of sprintf
    13921415        sprintf(info, "nv>data tag %s id %d min %g max %g vmin %g vmax %g\n",
    1393                 tag, n, volPtr->wAxis.min(), volPtr->wAxis.max(),
     1416                tag, volDataID, volPtr->wAxis.min(), volPtr->wAxis.max(),
    13941417                Volume::valueMin, Volume::valueMax);
    13951418        nWritten  = write(0, info, strlen(info));
    … …  
    16831706             Tcl_Obj *const *objv)
    16841707{
    1685     NanoVis::volume[1]->data(false);
    1686     NanoVis::volume[1]->visible(false);
     1708    NanoVis::VolumeMap::iterator iter = NanoVis::volumeMap.find(1);
     1709    if (iter != NanoVis::volumeMap.end())
     1710    {
     1711        NanoVis::volumeMap[1]->data(false);
     1712        NanoVis::volumeMap[1]->visible(false);
     1713    }
    16871714    return TCL_OK;
    16881715}
    … …  
    24132440        NanoVis::SetHeightmapRanges();
    24142441    }
     2442
    24152443    NanoVis::render_legend(tf, HeightMap::valueMin, HeightMap::valueMax, w, h,
    2416         "label");
     2444       "label");
    24172445    return TCL_OK;
    24182446}
Note: See TracChangeset for help on using the changeset viewer.