Ignore:
Timestamp:
Aug 22, 2011, 2:15:12 AM (13 years ago)
Author:
ldelgass
Message:
  • Let graphics objects handle DataSet? cumulative range changes, track vectors as well as scalars, also supply cumulative ranges in setDataSet()
  • Be more consistent about naming enums and commands for vectors
  • Add constructor arguments to some graphics objects to speed initialization (eliminates some pipeline changes)
  • Apply a scale factor to glyphs based on cell sizes
  • Add line glyph shape
  • Don't delete ColorMaps? in use
  • Update graphics objects when a ColorMap? is edited
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

    r2393 r2402  
    6969    _cameraOrientation[2] = 0.0;
    7070    _cameraOrientation[3] = 0.0;
    71     _cumulativeDataRange[0] = 0.0;
    72     _cumulativeDataRange[1] = 1.0;
     71    _cumulativeScalarRange[0] = 0.0;
     72    _cumulativeScalarRange[1] = 1.0;
     73    _cumulativeVectorMagnitudeRange[0] = 0.0;
     74    _cumulativeVectorMagnitudeRange[1] = 1.0;
     75    for (int i = 0; i < 3; i++) {
     76        _cumulativeVectorComponentRange[i][0] = 0.0;
     77        _cumulativeVectorComponentRange[i][1] = 1.0;
     78    }
    7379    // clipping planes to prevent overdrawing axes
    7480    _activeClipPlanes = vtkSmartPointer<vtkPlaneCollection>::New();
    … …  
    263269    } while (doAll && itr != _contour2Ds.end());
    264270
     271    initCamera();
    265272    _needsRedraw = true;
    266273}
    … …  
    299306    } while (doAll && itr != _contour3Ds.end());
    300307
     308    initCamera();
    301309    _needsRedraw = true;
    302310}
    … …  
    335343    } while (doAll && itr != _glyphs.end());
    336344
     345    initCamera();
    337346    _needsRedraw = true;
    338347}
    … …  
    371380    } while (doAll && itr != _heightMaps.end());
    372381
     382    initCamera();
    373383    _needsRedraw = true;
    374384}
    … …  
    407417    } while (doAll && itr != _lics.end());
    408418
     419    initCamera();
    409420    _needsRedraw = true;
    410421}
    … …  
    443454    } while (doAll && itr != _molecules.end());
    444455
     456    initCamera();
    445457    _needsRedraw = true;
    446458}
    … …  
    479491    } while (doAll && itr != _polyDatas.end());
    480492
     493    initCamera();
    481494    _needsRedraw = true;
    482495}
    … …  
    515528    } while (doAll && itr != _pseudoColors.end());
    516529
     530    initCamera();
    517531    _needsRedraw = true;
    518532}
    … …  
    551565    } while (doAll && itr != _streamlines.end());
    552566
     567    initCamera();
    553568    _needsRedraw = true;
    554569}
    … …  
    587602    } while (doAll && itr != _volumes.end());
    588603
     604    initCamera();
    589605    _needsRedraw = true;
    590606}
    … …  
    634650
    635651    // Update cumulative data range
    636     collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
    637     updateRanges(_useCumulativeRange);
    638 
     652    updateRanges();
     653
     654    initCamera();
    639655    _needsRedraw = true;
    640656}
    … …  
    649665    DataSetHashmap::iterator itr = _dataSets.find(id);
    650666    if (itr == _dataSets.end()) {
     667#ifdef DEBUG
    651668        TRACE("DataSet not found: %s", id.c_str());
     669#endif
    652670        return NULL;
    653671    } else
    … …  
    663681    if (ds) {
    664682        bool ret = ds->setDataFile(filename);
    665         collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
    666         updateRanges(_useCumulativeRange);
     683        updateRanges();
    667684        _needsRedraw = true;
    668685        return ret;
    … …  
    679696    if (ds) {
    680697        bool ret = ds->setData(data, nbytes);
    681         collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
    682         updateRanges(_useCumulativeRange);
     698        updateRanges();
    683699        _needsRedraw = true;
    684700        return ret;
    … …  
    712728
    713729    if (ret) {
    714         collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
    715         updateRanges(_useCumulativeRange);
     730         updateRanges();
    716731        _needsRedraw = true;
    717732    }
    … …  
    745760
    746761    if (ret) {
    747         collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
    748         updateRanges(_useCumulativeRange);
     762        updateRanges();
    749763        _needsRedraw = true;
    750764    }
    … …  
    762776        _useCumulativeRange = state;
    763777        _cumulativeRangeOnlyVisible = onlyVisible;
    764         collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
    765         updateRanges(_useCumulativeRange);
     778        updateRanges();
    766779        _needsRedraw = true;
    767780    }
    768781}
    769782
    770 void Renderer::resetAxes()
     783void Renderer::resetAxes(double bounds[6])
    771784{
    772785    TRACE("Resetting axes");
    … …  
    793806            _renderer->AddViewProp(_cubeAxesActor);
    794807        }
    795         double bounds[6];
    796         collectBounds(bounds, false);
    797         _cubeAxesActor->SetBounds(bounds);
     808        if (bounds == NULL) {
     809            double newBounds[6];
     810            collectBounds(newBounds, false);
     811            _cubeAxesActor->SetBounds(newBounds);
     812        } else {
     813            _cubeAxesActor->SetBounds(bounds);
     814        }
    798815    }
    799816}
    … …  
    11371154
    11381155/**
    1139  * \brief Add a color map for use in the Renderer
     1156 * \brief Notify graphics objects that color map has changed
     1157 */
     1158void Renderer::updateColorMap(ColorMap *cmap)
     1159{
     1160    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
     1161         itr != _contour3Ds.end(); ++itr) {
     1162        if (itr->second->getColorMap() == cmap) {
     1163            itr->second->updateColorMap();
     1164            _needsRedraw = true;
     1165        }
     1166    }
     1167    for (GlyphsHashmap::iterator itr = _glyphs.begin();
     1168         itr != _glyphs.end(); ++itr) {
     1169        if (itr->second->getColorMap() == cmap) {
     1170            itr->second->updateColorMap();
     1171            _needsRedraw = true;
     1172        }
     1173    }
     1174    for (HeightMapHashmap::iterator itr = _heightMaps.begin();
     1175         itr != _heightMaps.end(); ++itr) {
     1176        if (itr->second->getColorMap() == cmap) {
     1177            itr->second->updateColorMap();
     1178            _needsRedraw = true;
     1179        }
     1180    }
     1181    for (LICHashmap::iterator itr = _lics.begin();
     1182         itr != _lics.end(); ++itr) {
     1183        if (itr->second->getColorMap() == cmap) {
     1184            itr->second->updateColorMap();
     1185            _needsRedraw = true;
     1186        }
     1187    }
     1188    for (MoleculeHashmap::iterator itr = _molecules.begin();
     1189         itr != _molecules.end(); ++itr) {
     1190        if (itr->second->getColorMap() == cmap) {
     1191            itr->second->updateColorMap();
     1192            _needsRedraw = true;
     1193        }
     1194    }
     1195    for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
     1196         itr != _pseudoColors.end(); ++itr) {
     1197        if (itr->second->getColorMap() == cmap) {
     1198            itr->second->updateColorMap();
     1199            _needsRedraw = true;
     1200        }
     1201    }
     1202    for (StreamlinesHashmap::iterator itr = _streamlines.begin();
     1203         itr != _streamlines.end(); ++itr) {
     1204        if (itr->second->getColorMap() == cmap) {
     1205            itr->second->updateColorMap();
     1206            _needsRedraw = true;
     1207        }
     1208    }
     1209    for (VolumeHashmap::iterator itr = _volumes.begin();
     1210         itr != _volumes.end(); ++itr) {
     1211        if (itr->second->getColorMap() == cmap) {
     1212            itr->second->updateColorMap();
     1213            _needsRedraw = true;
     1214        }
     1215    }
     1216}
     1217
     1218/**
     1219 * \brief Check if a ColorMap is in use by graphics objects
     1220 */
     1221bool Renderer::colorMapUsed(ColorMap *cmap)
     1222{
     1223    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
     1224         itr != _contour3Ds.end(); ++itr) {
     1225        if (itr->second->getColorMap() == cmap)
     1226            return true;
     1227    }
     1228    for (GlyphsHashmap::iterator itr = _glyphs.begin();
     1229         itr != _glyphs.end(); ++itr) {
     1230        if (itr->second->getColorMap() == cmap)
     1231            return true;
     1232    }
     1233    for (HeightMapHashmap::iterator itr = _heightMaps.begin();
     1234         itr != _heightMaps.end(); ++itr) {
     1235        if (itr->second->getColorMap() == cmap)
     1236            return true;
     1237    }
     1238    for (LICHashmap::iterator itr = _lics.begin();
     1239         itr != _lics.end(); ++itr) {
     1240        if (itr->second->getColorMap() == cmap)
     1241            return true;
     1242    }
     1243    for (MoleculeHashmap::iterator itr = _molecules.begin();
     1244         itr != _molecules.end(); ++itr) {
     1245        if (itr->second->getColorMap() == cmap)
     1246            return true;
     1247    }
     1248    for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
     1249         itr != _pseudoColors.end(); ++itr) {
     1250        if (itr->second->getColorMap() == cmap)
     1251            return true;
     1252    }
     1253    for (StreamlinesHashmap::iterator itr = _streamlines.begin();
     1254         itr != _streamlines.end(); ++itr) {
     1255        if (itr->second->getColorMap() == cmap)
     1256            return true;
     1257    }
     1258    for (VolumeHashmap::iterator itr = _volumes.begin();
     1259         itr != _volumes.end(); ++itr) {
     1260        if (itr->second->getColorMap() == cmap)
     1261            return true;
     1262    }
     1263    return false;
     1264}
     1265
     1266/**
     1267 * \brief Add/replace a ColorMap for use in the Renderer
    11401268 */
    11411269void Renderer::addColorMap(const ColorMapId& id, ColorMap *colorMap)
    … …  
    11441272        colorMap->build();
    11451273        if (getColorMap(id) != NULL) {
    1146             WARN("Replacing existing ColorMap %s", id.c_str());
    1147             deleteColorMap(id);
    1148         }
    1149         _colorMaps[id] = colorMap;
     1274            TRACE("Replacing existing ColorMap %s", id.c_str());
     1275            // Copy to current colormap to avoid invalidating
     1276            // pointers in graphics objects using the color map
     1277            *_colorMaps[id] = *colorMap;
     1278            delete colorMap;
     1279            // Notify graphics objects of change
     1280            updateColorMap(_colorMaps[id]);
     1281        } else
     1282            _colorMaps[id] = colorMap;
    11501283    } else {
    11511284        ERROR("NULL ColorMap");
    … …  
    11911324
    11921325    do {
     1326        if (itr->second->getName().compare("default") == 0 ||
     1327            itr->second->getName().compare("volumeDefault") == 0 ||
     1328            itr->second->getName().compare("elementDefault") == 0) {
     1329            if (id.compare("all") != 0) {
     1330                WARN("Cannot delete a default color map");
     1331            }
     1332            continue;
     1333        } else if (colorMapUsed(itr->second)) {
     1334            WARN("Cannot delete color map '%s', it is in use", itr->second->getName().c_str());
     1335            continue;
     1336        }
     1337
    11931338        TRACE("Deleting ColorMap %s", itr->second->getName().c_str());
    11941339
    1195         // TODO: Check if color map is used in PseudoColors?
    11961340        delete itr->second;
    11971341        itr = _colorMaps.erase(itr);
    … …  
    12201364        _legendRenderWindow->DoubleBufferOff();
    12211365        _legendRenderWindow->OffScreenRenderingOn();
     1366#else
     1367        _legendRenderWindow->DoubleBufferOn();
     1368        _legendRenderWindow->SwapBuffersOff();
    12221369#endif
    12231370    }
    … …  
    12391386    vtkSmartPointer<vtkLookupTable> lut = colorMap->getLookupTable();
    12401387    if (dataSetID.compare("all") == 0) {
    1241         lut->SetRange(_cumulativeDataRange);
     1388        lut->SetRange(_cumulativeScalarRange);
    12421389    } else {
    12431390        DataSet *dataSet = getDataSet(dataSetID);
    12441391        if (dataSet == NULL) {
    1245             lut->SetRange(_cumulativeDataRange);
     1392            lut->SetRange(_cumulativeScalarRange);
    12461393        } else {
    12471394            double range[2];
    1248             dataSet->getDataRange(range);
     1395            dataSet->getScalarRange(range);
    12491396            lut->SetRange(range);
    12501397        }
    … …  
    13101457 * \brief Create a new Contour2D and associate it with the named DataSet
    13111458 */
    1312 void Renderer::addContour2D(const DataSetId& id)
     1459void Renderer::addContour2D(const DataSetId& id, int numContours)
    13131460{
    13141461    DataSetHashmap::iterator itr;
    … …  
    13351482        }
    13361483
    1337         Contour2D *contour = new Contour2D();
     1484        Contour2D *contour = new Contour2D(numContours);
    13381485        _contour2Ds[dsID] = contour;
    13391486
    1340         contour->setDataSet(ds);
     1487        contour->setDataSet(ds,
     1488                            _useCumulativeRange,
     1489                            _cumulativeScalarRange,
     1490                            _cumulativeVectorMagnitudeRange,
     1491                            _cumulativeVectorComponentRange);
    13411492
    13421493        _renderer->AddViewProp(contour->getProp());
    … …  
    13481499
    13491500/**
     1501 * \brief Create a new Contour2D and associate it with the named DataSet
     1502 */
     1503void Renderer::addContour2D(const DataSetId& id, const std::vector<double>& contours)
     1504{
     1505    DataSetHashmap::iterator itr;
     1506
     1507    bool doAll = false;
     1508
     1509    if (id.compare("all") == 0) {
     1510        itr = _dataSets.begin();
     1511    } else {
     1512        itr = _dataSets.find(id);
     1513    }
     1514    if (itr == _dataSets.end()) {
     1515        ERROR("Unknown dataset %s", id.c_str());
     1516        return;
     1517    }
     1518
     1519    do {
     1520        DataSet *ds = itr->second;
     1521        const DataSetId& dsID = ds->getName();
     1522
     1523        if (getContour2D(dsID)) {
     1524            WARN("Replacing existing Contour2D %s", dsID.c_str());
     1525            deleteContour2D(dsID);
     1526        }
     1527
     1528        Contour2D *contour = new Contour2D(contours);
     1529        _contour2Ds[dsID] = contour;
     1530
     1531        contour->setDataSet(ds,
     1532                            _useCumulativeRange,
     1533                            _cumulativeScalarRange,
     1534                            _cumulativeVectorMagnitudeRange,
     1535                            _cumulativeVectorComponentRange);
     1536
     1537        _renderer->AddViewProp(contour->getProp());
     1538    } while (doAll && ++itr != _dataSets.end());
     1539
     1540    initCamera();
     1541    _needsRedraw = true;
     1542}
     1543
     1544/**
    13501545 * \brief Get the Contour2D associated with a named DataSet
    13511546 */
    … …  
    13551550
    13561551    if (itr == _contour2Ds.end()) {
     1552#ifdef DEBUG
    13571553        TRACE("Contour2D not found: %s", id.c_str());
     1554#endif
    13581555        return NULL;
    13591556    } else
    … …  
    15221719
    15231720    do {
    1524         if (_useCumulativeRange) {
    1525             itr->second->setContours(numContours, _cumulativeDataRange);
    1526         } else {
    1527             itr->second->setContours(numContours);
    1528         }
     1721        itr->second->setContours(numContours);
    15291722    } while (doAll && ++itr != _contour2Ds.end());
    15301723
    … …  
    16991892 * \brief Create a new Contour3D and associate it with the named DataSet
    17001893 */
    1701 void Renderer::addContour3D(const DataSetId& id)
     1894void Renderer::addContour3D(const DataSetId& id, int numContours)
    17021895{
    17031896    DataSetHashmap::iterator itr;
    … …  
    17241917        }
    17251918
    1726         Contour3D *contour = new Contour3D();
     1919        Contour3D *contour = new Contour3D(numContours);
    17271920        _contour3Ds[dsID] = contour;
    17281921
    1729         contour->setDataSet(ds);
    1730 
    1731         // Use the default color map
    1732         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    1733         ColorMap *cmap = getColorMap("default");
    1734         lut->DeepCopy(cmap->getLookupTable());
    1735         if (_useCumulativeRange) {
    1736             lut->SetRange(_cumulativeDataRange);
    1737         } else {
    1738             double range[2];
    1739             ds->getDataRange(range);
    1740             lut->SetRange(range);
    1741         }
    1742 
    1743         contour->setLookupTable(lut);
     1922        contour->setDataSet(ds,
     1923                            _useCumulativeRange,
     1924                            _cumulativeScalarRange,
     1925                            _cumulativeVectorMagnitudeRange,
     1926                            _cumulativeVectorComponentRange);
    17441927
    17451928        _renderer->AddViewProp(contour->getProp());
    … …  
    17531936
    17541937/**
     1938 * \brief Create a new Contour3D and associate it with the named DataSet
     1939 */
     1940void Renderer::addContour3D(const DataSetId& id,const std::vector<double>& contours)
     1941{
     1942    DataSetHashmap::iterator itr;
     1943
     1944    bool doAll = false;
     1945
     1946    if (id.compare("all") == 0) {
     1947        itr = _dataSets.begin();
     1948    } else {
     1949        itr = _dataSets.find(id);
     1950    }
     1951    if (itr == _dataSets.end()) {
     1952        ERROR("Unknown dataset %s", id.c_str());
     1953        return;
     1954    }
     1955
     1956    do {
     1957        DataSet *ds = itr->second;
     1958        const DataSetId& dsID = ds->getName();
     1959
     1960        if (getContour3D(dsID)) {
     1961            WARN("Replacing existing Contour3D %s", dsID.c_str());
     1962            deleteContour3D(dsID);
     1963        }
     1964
     1965        Contour3D *contour = new Contour3D(contours);
     1966        _contour3Ds[dsID] = contour;
     1967
     1968        contour->setDataSet(ds,
     1969                            _useCumulativeRange,
     1970                            _cumulativeScalarRange,
     1971                            _cumulativeVectorMagnitudeRange,
     1972                            _cumulativeVectorComponentRange);
     1973
     1974        _renderer->AddViewProp(contour->getProp());
     1975    } while (doAll && ++itr != _dataSets.end());
     1976
     1977    if (_cameraMode == IMAGE)
     1978        setCameraMode(PERSPECTIVE);
     1979    initCamera();
     1980    _needsRedraw = true;
     1981}
     1982
     1983/**
    17551984 * \brief Get the Contour3D associated with a named DataSet
    17561985 */
    … …  
    17601989
    17611990    if (itr == _contour3Ds.end()) {
     1991#ifdef DEBUG
    17621992        TRACE("Contour3D not found: %s", id.c_str());
     1993#endif
    17631994        return NULL;
    17641995    } else
    … …  
    19272158
    19282159    do {
    1929         if (_useCumulativeRange) {
    1930             itr->second->setContours(numContours, _cumulativeDataRange);
    1931         } else {
    1932             itr->second->setContours(numContours);
    1933         }
    1934     } while (doAll && ++itr != _contour3Ds.end());
     2160        itr->second->setContours(numContours);
     2161     } while (doAll && ++itr != _contour3Ds.end());
    19352162
    19362163    initCamera();
    … …  
    20522279              itr->second->getDataSet()->getName().c_str());
    20532280
    2054         // Make a copy of the generic colormap lookup table, so
    2055         // data range can be set in the copy table to match the
    2056         // dataset being plotted
    2057         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    2058         lut->DeepCopy(cmap->getLookupTable());
    2059 
    2060         if (_useCumulativeRange) {
    2061             lut->SetRange(_cumulativeDataRange);
    2062         } else {
    2063             if (itr->second->getDataSet() != NULL) {
    2064                 double range[2];
    2065                 itr->second->getDataSet()->getDataRange(range);
    2066                 lut->SetRange(range);
    2067             }
    2068         }
    2069 
    2070         itr->second->setLookupTable(lut);
     2281        itr->second->setColorMap(cmap);
    20712282    } while (doAll && ++itr != _contour3Ds.end());
    20722283
    … …  
    22402451 * \brief Create a new Glyphs and associate it with the named DataSet
    22412452 */
    2242 void Renderer::addGlyphs(const DataSetId& id)
     2453void Renderer::addGlyphs(const DataSetId& id, Glyphs::GlyphShape shape)
    22432454{
    22442455    DataSetHashmap::iterator itr;
    … …  
    22652476        }
    22662477
    2267         Glyphs *glyphs = new Glyphs();
     2478        Glyphs *glyphs = new Glyphs(shape);
    22682479        _glyphs[dsID] = glyphs;
    22692480
    2270         glyphs->setDataSet(ds);
    2271 
    2272         // Use the default color map
    2273         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    2274         ColorMap *cmap = getColorMap("default");
    2275         lut->DeepCopy(cmap->getLookupTable());
    2276         if (_useCumulativeRange) {
    2277             lut->SetRange(_cumulativeDataRange);
    2278         } else {
    2279             double range[2];
    2280             ds->getDataRange(range);
    2281             lut->SetRange(range);
    2282         }
    2283 
    2284         glyphs->setLookupTable(lut);
     2481        glyphs->setDataSet(ds,
     2482                           _useCumulativeRange,
     2483                           _cumulativeScalarRange,
     2484                           _cumulativeVectorMagnitudeRange,
     2485                           _cumulativeVectorComponentRange);
    22852486
    22862487        _renderer->AddViewProp(glyphs->getProp());
    … …  
    23022503
    23032504    if (itr == _glyphs.end()) {
     2505#ifdef DEBUG
    23042506        TRACE("Glyphs not found: %s", id.c_str());
     2507#endif
    23052508        return NULL;
    23062509    } else
    … …  
    25062709              itr->second->getDataSet()->getName().c_str());
    25072710
    2508         // Make a copy of the generic colormap lookup table, so
    2509         // data range can be set in the copy table to match the
    2510         // dataset being plotted
    2511         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    2512         lut->DeepCopy(cmap->getLookupTable());
    2513 
    2514         if (_useCumulativeRange) {
    2515             lut->SetRange(_cumulativeDataRange);
    2516         } else {
    2517             if (itr->second->getDataSet() != NULL) {
    2518                 double range[2];
    2519                 itr->second->getDataSet()->getDataRange(range);
    2520                 lut->SetRange(range);
    2521             }
    2522         }
    2523 
    2524         itr->second->setLookupTable(lut);
     2711        itr->second->setColorMap(cmap);
    25252712    } while (doAll && ++itr != _glyphs.end());
    25262713
    … …  
    28333020 * \brief Create a new HeightMap and associate it with the named DataSet
    28343021 */
    2835 void Renderer::addHeightMap(const DataSetId& id)
     3022void Renderer::addHeightMap(const DataSetId& id, int numContours)
    28363023{
    28373024    DataSetHashmap::iterator itr;
    … …  
    28583045        }
    28593046
    2860         HeightMap *hmap = new HeightMap();
     3047        HeightMap *hmap = new HeightMap(numContours);
    28613048        _heightMaps[dsID] = hmap;
    28623049
    2863         hmap->setDataSet(ds);
    2864 
    2865         // Use the default color map
    2866         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    2867         ColorMap *cmap = getColorMap("default");
    2868         lut->DeepCopy(cmap->getLookupTable());
    2869         if (_useCumulativeRange) {
    2870             lut->SetRange(_cumulativeDataRange);
    2871         } else {
    2872             double range[2];
    2873             ds->getDataRange(range);
    2874             lut->SetRange(range);
    2875         }
    2876 
    2877         hmap->setLookupTable(lut);
     3050        hmap->setDataSet(ds,
     3051                         _useCumulativeRange,
     3052                         _cumulativeScalarRange,
     3053                         _cumulativeVectorMagnitudeRange,
     3054                         _cumulativeVectorComponentRange);
    28783055
    28793056        _renderer->AddViewProp(hmap->getProp());
    … …  
    28883065
    28893066/**
     3067 * \brief Create a new HeightMap and associate it with the named DataSet
     3068 */
     3069void Renderer::addHeightMap(const DataSetId& id, const std::vector<double>& contours)
     3070{
     3071    DataSetHashmap::iterator itr;
     3072
     3073    bool doAll = false;
     3074
     3075    if (id.compare("all") == 0) {
     3076        itr = _dataSets.begin();
     3077    } else {
     3078        itr = _dataSets.find(id);
     3079    }
     3080    if (itr == _dataSets.end()) {
     3081        ERROR("Unknown dataset %s", id.c_str());
     3082        return;
     3083    }
     3084
     3085    do {
     3086        DataSet *ds = itr->second;
     3087        const DataSetId& dsID = ds->getName();
     3088
     3089        if (getHeightMap(dsID)) {
     3090            WARN("Replacing existing HeightMap %s", dsID.c_str());
     3091            deleteHeightMap(dsID);
     3092        }
     3093
     3094        HeightMap *hmap = new HeightMap(contours);
     3095        _heightMaps[dsID] = hmap;
     3096
     3097        hmap->setDataSet(ds,
     3098                         _useCumulativeRange,
     3099                         _cumulativeScalarRange,
     3100                         _cumulativeVectorMagnitudeRange,
     3101                         _cumulativeVectorComponentRange);
     3102
     3103        _renderer->AddViewProp(hmap->getProp());
     3104    } while (doAll && ++itr != _dataSets.end());
     3105
     3106    if (_cameraMode == IMAGE)
     3107        setCameraMode(PERSPECTIVE);
     3108    initCamera();
     3109
     3110    _needsRedraw = true;
     3111}
     3112
     3113/**
    28903114 * \brief Get the HeightMap associated with a named DataSet
    28913115 */
    … …  
    28953119
    28963120    if (itr == _heightMaps.end()) {
     3121#ifdef DEBUG
    28973122        TRACE("HeightMap not found: %s", id.c_str());
     3123#endif
    28983124        return NULL;
    28993125    } else
    … …  
    31313357              itr->second->getDataSet()->getName().c_str());
    31323358
    3133         // Make a copy of the generic colormap lookup table, so
    3134         // data range can be set in the copy table to match the
    3135         // dataset being plotted
    3136         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    3137         lut->DeepCopy(cmap->getLookupTable());
    3138 
    3139         if (_useCumulativeRange) {
    3140             lut->SetRange(_cumulativeDataRange);
    3141         } else {
    3142             if (itr->second->getDataSet() != NULL) {
    3143                 double range[2];
    3144                 itr->second->getDataSet()->getDataRange(range);
    3145                 lut->SetRange(range);
    3146             }
    3147         }
    3148 
    3149         itr->second->setLookupTable(lut);
     3359        itr->second->setColorMap(cmap);
    31503360    } while (doAll && ++itr != _heightMaps.end());
    31513361
    … …  
    31743384
    31753385    do {
    3176         if (_useCumulativeRange) {
    3177             itr->second->setContours(numContours, _cumulativeDataRange);
    3178         } else {
    3179             itr->second->setContours(numContours);
    3180         }
     3386        itr->second->setContours(numContours);
    31813387    } while (doAll && ++itr != _heightMaps.end());
    31823388
    … …  
    34903696        _lics[dsID] = lic;
    34913697
    3492         lic->setDataSet(ds);
     3698        lic->setDataSet(ds,
     3699                        _useCumulativeRange,
     3700                        _cumulativeScalarRange,
     3701                        _cumulativeVectorMagnitudeRange,
     3702                        _cumulativeVectorComponentRange);
    34933703
    34943704        _renderer->AddViewProp(lic->getProp());
    … …  
    35093719
    35103720    if (itr == _lics.end()) {
     3721#ifdef DEBUG
    35113722        TRACE("LIC not found: %s", id.c_str());
     3723#endif
    35123724        return NULL;
    35133725    } else
    … …  
    37153927              itr->second->getDataSet()->getName().c_str());
    37163928
    3717         // Make a copy of the generic colormap lookup table, so
    3718         // data range can be set in the copy table to match the
    3719         // dataset being plotted
    3720         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    3721         lut->DeepCopy(cmap->getLookupTable());
    3722 
    3723         if (_useCumulativeRange) {
    3724             lut->SetRange(_cumulativeDataRange);
    3725         } else {
    3726             if (itr->second->getDataSet() != NULL) {
    3727                 double range[2];
    3728                 itr->second->getDataSet()->getDataRange(range);
    3729                 lut->SetRange(range);
    3730             }
    3731         }
    3732 
    3733         itr->second->setLookupTable(lut);
     3929        itr->second->setColorMap(cmap);
    37343930    } while (doAll && ++itr != _lics.end());
    37353931
    … …  
    39524148
    39534149    if (itr == _molecules.end()) {
     4150#ifdef DEBUG
    39544151        TRACE("Molecule not found: %s", id.c_str());
     4152#endif
    39554153        return NULL;
    39564154    } else
    … …  
    41294327              itr->second->getDataSet()->getName().c_str());
    41304328
    4131         // Make a copy of the generic colormap lookup table, so
    4132         // data range can be set in the copy table to match the
    4133         // dataset being plotted
    4134         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    4135         lut->DeepCopy(cmap->getLookupTable());
    4136 
    4137         if (_useCumulativeRange) {
    4138             lut->SetRange(_cumulativeDataRange);
    4139         } else {
    4140             if (itr->second->getDataSet() != NULL) {
    4141                 double range[2];
    4142                 itr->second->getDataSet()->getDataRange(range);
    4143                 lut->SetRange(range);
    4144             }
    4145         }
    4146 
    4147         itr->second->setLookupTable(lut);
     4329        itr->second->setColorMap(cmap);
    41484330    } while (doAll && ++itr != _molecules.end());
    41494331
    … …  
    44744656
    44754657    if (itr == _polyDatas.end()) {
     4658#ifdef DEBUG
    44764659        TRACE("PolyData not found: %s", id.c_str());
     4660#endif
    44774661        return NULL;
    44784662    } else
    … …  
    48685052        _pseudoColors[dsID] = pc;
    48695053
    4870         pc->setDataSet(ds);
    4871 
    4872         // Use the default color map
    4873         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    4874         ColorMap *cmap = getColorMap("default");
    4875         lut->DeepCopy(cmap->getLookupTable());
    4876         if (_useCumulativeRange) {
    4877             lut->SetRange(_cumulativeDataRange);
    4878         } else {
    4879             double range[2];
    4880             ds->getDataRange(range);
    4881             lut->SetRange(range);
    4882         }
    4883 
    4884         pc->setLookupTable(lut);
     5054        pc->setDataSet(ds,
     5055                       _useCumulativeRange,
     5056                       _cumulativeScalarRange,
     5057                       _cumulativeVectorMagnitudeRange,
     5058                       _cumulativeVectorComponentRange);
    48855059
    48865060        _renderer->AddViewProp(pc->getProp());
    … …  
    48995073
    49005074    if (itr == _pseudoColors.end()) {
     5075#ifdef DEBUG
    49015076        TRACE("PseudoColor not found: %s", id.c_str());
     5077#endif
    49025078        return NULL;
    49035079    } else
    … …  
    50765252              itr->second->getDataSet()->getName().c_str());
    50775253
    5078         // Make a copy of the generic colormap lookup table, so
    5079         // data range can be set in the copy table to match the
    5080         // dataset being plotted
    5081         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    5082         lut->DeepCopy(cmap->getLookupTable());
    5083 
    5084         if (_useCumulativeRange) {
    5085             lut->SetRange(_cumulativeDataRange);
    5086         } else {
    5087             if (itr->second->getDataSet() != NULL) {
    5088                 double range[2];
    5089                 itr->second->getDataSet()->getDataRange(range);
    5090                 lut->SetRange(range);
    5091             }
    5092         }
    5093 
    5094         itr->second->setLookupTable(lut);
     5254        itr->second->setColorMap(cmap);
    50955255    } while (doAll && ++itr != _pseudoColors.end());
    50965256
    … …  
    53275487        _streamlines[dsID] = streamlines;
    53285488
    5329         streamlines->setDataSet(ds);
    5330 
    5331         // Use the default color map
    5332         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    5333         ColorMap *cmap = getColorMap("default");
    5334         lut->DeepCopy(cmap->getLookupTable());
    5335 
    5336         if (_useCumulativeRange) {
    5337             lut->SetRange(_cumulativeDataRange);
    5338         } else {
    5339             double range[2];
    5340             ds->getDataRange(range);
    5341             lut->SetRange(range);
    5342         }
    5343         streamlines->setLookupTable(lut);
     5489        streamlines->setDataSet(ds,
     5490                                _useCumulativeRange,
     5491                                _cumulativeScalarRange,
     5492                                _cumulativeVectorMagnitudeRange,
     5493                                _cumulativeVectorComponentRange);
    53445494
    53455495        _renderer->AddViewProp(streamlines->getProp());
    … …  
    53585508
    53595509    if (itr == _streamlines.end()) {
     5510#ifdef DEBUG
    53605511        TRACE("Streamlines not found: %s", id.c_str());
     5512#endif
    53615513        return NULL;
    53625514    } else
    … …  
    59016053              itr->second->getDataSet()->getName().c_str());
    59026054
    5903         // Make a copy of the generic colormap lookup table, so
    5904         // data range can be set in the copy table to match the
    5905         // dataset being plotted
    5906         vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
    5907         lut->DeepCopy(cmap->getLookupTable());
    5908 
    5909         if (_useCumulativeRange) {
    5910             lut->SetRange(_cumulativeDataRange);
    5911         } else {
    5912             if (itr->second->getDataSet() != NULL) {
    5913                 double range[2];
    5914                 itr->second->getDataSet()->getDataRange(range);
    5915                 lut->SetRange(range);
    5916             }
    5917         }
    5918 
    5919         itr->second->setLookupTable(lut);
     6055        itr->second->setColorMap(cmap);
    59206056    } while (doAll && ++itr != _streamlines.end());
    59216057
    … …  
    61206256        _volumes[dsID] = volume;
    61216257
    6122         volume->setDataSet(ds);
    6123 
    6124         if (_useCumulativeRange) {
    6125             ColorMap *cmap = volume->getColorMap();
    6126             volume->setColorMap(cmap, _cumulativeDataRange);
    6127         }
     6258        volume->setDataSet(ds,
     6259                           _useCumulativeRange,
     6260                           _cumulativeScalarRange,
     6261                           _cumulativeVectorMagnitudeRange,
     6262                           _cumulativeVectorComponentRange );
    61286263
    61296264        _renderer->AddViewProp(volume->getProp());
    … …  
    61446279
    61456280    if (itr == _volumes.end()) {
     6281#ifdef DEBUG
    61466282        TRACE("Volume not found: %s", id.c_str());
     6283#endif
    61476284        return NULL;
    61486285    } else
    … …  
    63216458              itr->second->getDataSet()->getName().c_str());
    63226459
    6323         if (_useCumulativeRange) {
    6324             itr->second->setColorMap(cmap, _cumulativeDataRange);
    6325         } else {
    6326             itr->second->setColorMap(cmap);
    6327         }
     6460        itr->second->setColorMap(cmap);
    63286461    } while (doAll && ++itr != _volumes.end());
    63296462
    … …  
    73507483/**
    73517484 * \brief Update data ranges for color-mapping and contours
    7352  *
    7353  * \param[in] useCumulative Use cumulative range of all DataSets
    7354  */
    7355 void Renderer::updateRanges(bool useCumulative)
    7356 {
     7485 */
     7486void Renderer::updateRanges()
     7487{
     7488    collectDataRanges();
     7489
    73577490    for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
    73587491         itr != _contour2Ds.end(); ++itr) {
    7359         // Only need to update range if using evenly spaced contours
    7360         if (itr->second->getContourList().empty()) {
    7361             if (useCumulative) {
    7362                 itr->second->setContours(itr->second->getNumContours(), _cumulativeDataRange);
    7363             } else {
    7364                 itr->second->setContours(itr->second->getNumContours());
    7365             }
    7366         }
     7492        itr->second->updateRanges(_useCumulativeRange,
     7493                                  _cumulativeScalarRange,
     7494                                  _cumulativeVectorMagnitudeRange,
     7495                                  _cumulativeVectorComponentRange);
    73677496    }
    73687497    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
    73697498         itr != _contour3Ds.end(); ++itr) {
    7370         // Only need to update range if using evenly spaced contours
    7371         if (itr->second->getContourList().empty()) {
    7372             if (useCumulative) {
    7373                 itr->second->setContours(itr->second->getNumContours(), _cumulativeDataRange);
    7374             } else {
    7375                 itr->second->setContours(itr->second->getNumContours());
    7376             }
    7377         }
     7499        itr->second->updateRanges(_useCumulativeRange,
     7500                                  _cumulativeScalarRange,
     7501                                  _cumulativeVectorMagnitudeRange,
     7502                                  _cumulativeVectorComponentRange);
    73787503    }
    73797504    for (GlyphsHashmap::iterator itr = _glyphs.begin();
    73807505         itr != _glyphs.end(); ++itr) {
    7381         vtkLookupTable *lut = itr->second->getLookupTable();
    7382         if (lut) {
    7383             if (useCumulative) {
    7384                 lut->SetRange(_cumulativeDataRange);
    7385             } else {
    7386                 double range[2];
    7387                 if (itr->second->getDataSet()) {
    7388                     itr->second->getDataSet()->getDataRange(range);
    7389                     lut->SetRange(range);
    7390                 }
    7391             }
    7392         }
     7506        itr->second->updateRanges(_useCumulativeRange,
     7507                                  _cumulativeScalarRange,
     7508                                  _cumulativeVectorMagnitudeRange,
     7509                                  _cumulativeVectorComponentRange);
    73937510    }
    73947511    for (HeightMapHashmap::iterator itr = _heightMaps.begin();
    73957512         itr != _heightMaps.end(); ++itr) {
    7396         vtkLookupTable *lut = itr->second->getLookupTable();
    7397         if (lut) {
    7398             if (useCumulative) {
    7399                 lut->SetRange(_cumulativeDataRange);
    7400             } else {
    7401                 double range[2];
    7402                 if (itr->second->getDataSet()) {
    7403                     itr->second->getDataSet()->getDataRange(range);
    7404                     lut->SetRange(range);
    7405                 }
    7406             }
    7407         }
    7408         // Only need to update contour range if using evenly spaced contours
    7409         if (itr->second->getContourList().empty()) {
    7410             if (useCumulative) {
    7411                 itr->second->setContours(itr->second->getNumContours(), _cumulativeDataRange);
    7412             } else {
    7413                 itr->second->setContours(itr->second->getNumContours());
    7414             }
    7415         }
     7513        itr->second->updateRanges(_useCumulativeRange,
     7514                                  _cumulativeScalarRange,
     7515                                  _cumulativeVectorMagnitudeRange,
     7516                                  _cumulativeVectorComponentRange);
    74167517    }
    74177518    for (LICHashmap::iterator itr = _lics.begin();
    74187519         itr != _lics.end(); ++itr) {
    7419         vtkLookupTable *lut = itr->second->getLookupTable();
    7420         if (lut) {
    7421             if (useCumulative) {
    7422                 lut->SetRange(_cumulativeDataRange);
    7423             } else {
    7424                 double range[2];
    7425                 if (itr->second->getDataSet()) {
    7426                     itr->second->getDataSet()->getDataRange(range);
    7427                     lut->SetRange(range);
    7428                 }
    7429             }
    7430         }
     7520        itr->second->updateRanges(_useCumulativeRange,
     7521                                  _cumulativeScalarRange,
     7522                                  _cumulativeVectorMagnitudeRange,
     7523                                  _cumulativeVectorComponentRange);
     7524    }
     7525    for (MoleculeHashmap::iterator itr = _molecules.begin();
     7526         itr != _molecules.end(); ++itr) {
     7527        itr->second->updateRanges(_useCumulativeRange,
     7528                                  _cumulativeScalarRange,
     7529                                  _cumulativeVectorMagnitudeRange,
     7530                                  _cumulativeVectorComponentRange);
    74317531    }
    74327532    for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
    74337533         itr != _pseudoColors.end(); ++itr) {
    7434         vtkLookupTable *lut = itr->second->getLookupTable();
    7435         if (lut) {
    7436             if (useCumulative) {
    7437                 lut->SetRange(_cumulativeDataRange);
    7438             } else {
    7439                 double range[2];
    7440                 if (itr->second->getDataSet()) {
    7441                     itr->second->getDataSet()->getDataRange(range);
    7442                     lut->SetRange(range);
    7443                 }
    7444             }
    7445         }
     7534        itr->second->updateRanges(_useCumulativeRange,
     7535                                  _cumulativeScalarRange,
     7536                                  _cumulativeVectorMagnitudeRange,
     7537                                  _cumulativeVectorComponentRange);
    74467538    }
    74477539    for (StreamlinesHashmap::iterator itr = _streamlines.begin();
    74487540         itr != _streamlines.end(); ++itr) {
    7449         vtkLookupTable *lut = itr->second->getLookupTable();
    7450         if (lut) {
    7451             if (useCumulative) {
    7452                 lut->SetRange(_cumulativeDataRange);
    7453             } else {
    7454                 double range[2];
    7455                 if (itr->second->getDataSet()) {
    7456                     itr->second->getDataSet()->getDataRange(range);
    7457                     lut->SetRange(range);
    7458                 }
    7459             }
    7460         }
     7541        itr->second->updateRanges(_useCumulativeRange,
     7542                                  _cumulativeScalarRange,
     7543                                  _cumulativeVectorMagnitudeRange,
     7544                                  _cumulativeVectorComponentRange);
    74617545    }
    74627546    for (VolumeHashmap::iterator itr = _volumes.begin();
    74637547         itr != _volumes.end(); ++itr) {
    7464         ColorMap *cmap = itr->second->getColorMap();
    7465         if (cmap) {
    7466             if (useCumulative) {
    7467                 itr->second->setColorMap(cmap, _cumulativeDataRange);
    7468             } else {
    7469                 itr->second->setColorMap(cmap);
    7470             }
    7471         }
     7548        itr->second->updateRanges(_useCumulativeRange,
     7549                                  _cumulativeScalarRange,
     7550                                  _cumulativeVectorMagnitudeRange,
     7551                                  _cumulativeVectorComponentRange);
     7552    }
     7553}
     7554
     7555void Renderer::collectDataRanges()
     7556{
     7557    collectScalarRanges(_cumulativeScalarRange,
     7558                        _cumulativeRangeOnlyVisible);
     7559    collectVectorMagnitudeRanges(_cumulativeVectorMagnitudeRange,
     7560                                 _cumulativeRangeOnlyVisible);
     7561    for (int i = 0; i < 3; i++) {
     7562        collectVectorComponentRanges(_cumulativeVectorComponentRange[i], i,
     7563                                     _cumulativeRangeOnlyVisible);
    74727564    }
    74737565}
    … …  
    74797571 * \param[in] onlyVisible Only collect range of visible DataSets
    74807572 */
    7481 void Renderer::collectDataRanges(double *range, bool onlyVisible)
     7573void Renderer::collectScalarRanges(double *range, bool onlyVisible)
    74827574{
    74837575    range[0] = DBL_MAX;
    … …  
    74887580        if (!onlyVisible || itr->second->getVisibility()) {
    74897581            double r[2];
    7490             itr->second->getDataRange(r);
     7582            itr->second->getScalarRange(r);
    74917583            range[0] = min2(range[0], r[0]);
    74927584            range[1] = max2(range[1], r[1]);
    … …  
    74987590        range[1] = 1;
    74997591}
     7592
     7593/**
     7594 * \brief Collect cumulative data range of all DataSets
     7595 *
     7596 * \param[inout] range Data range of all DataSets
     7597 * \param[in] onlyVisible Only collect range of visible DataSets
     7598 */
     7599void Renderer::collectVectorMagnitudeRanges(double *range, bool onlyVisible)
     7600{
     7601    range[0] = DBL_MAX;
     7602    range[1] = -DBL_MAX;
     7603
     7604    for (DataSetHashmap::iterator itr = _dataSets.begin();
     7605         itr != _dataSets.end(); ++itr) {
     7606        if (!onlyVisible || itr->second->getVisibility()) {
     7607            double r[2];
     7608            itr->second->getVectorRange(r);
     7609            range[0] = min2(range[0], r[0]);
     7610            range[1] = max2(range[1], r[1]);
     7611        }
     7612    }
     7613    if (range[0] == DBL_MAX)
     7614        range[0] = 0;
     7615    if (range[1] == -DBL_MAX)
     7616        range[1] = 1;
     7617}
     7618
     7619/**
     7620 * \brief Collect cumulative data range of all DataSets
     7621 *
     7622 * \param[inout] range Data range of all DataSets
     7623 * \param[in] onlyVisible Only collect range of visible DataSets
     7624 */
     7625void Renderer::collectVectorComponentRanges(double *range, int component, bool onlyVisible)
     7626{
     7627    range[0] = DBL_MAX;
     7628    range[1] = -DBL_MAX;
     7629
     7630    for (DataSetHashmap::iterator itr = _dataSets.begin();
     7631         itr != _dataSets.end(); ++itr) {
     7632        if (!onlyVisible || itr->second->getVisibility()) {
     7633            double r[2];
     7634            itr->second->getVectorRange(r, component);
     7635            range[0] = min2(range[0], r[0]);
     7636            range[1] = max2(range[1], r[1]);
     7637        }
     7638    }
     7639    if (range[0] == DBL_MAX)
     7640        range[0] = 0;
     7641    if (range[1] == -DBL_MAX)
     7642        range[1] = 1;
     7643 }
    75007644
    75017645/**
    … …  
    75387682    case ORTHO:
    75397683        _renderer->GetActiveCamera()->ParallelProjectionOn();
    7540         resetAxes();
     7684        resetAxes(bounds);
    75417685        _renderer->ResetCamera(bounds);
    75427686        //computeScreenWorldCoords();
    … …  
    75447688    case PERSPECTIVE:
    75457689        _renderer->GetActiveCamera()->ParallelProjectionOff();
    7546         resetAxes();
     7690        resetAxes(bounds);
    75477691        _renderer->ResetCamera(bounds);
    75487692        //computeScreenWorldCoords();
Note: See TracChangeset for help on using the changeset viewer.