Ignore:
Timestamp:
Aug 24, 2012, 1:26:01 PM (12 years ago)
Author:
ldelgass
Message:

Support colormapping 2D isocontour lines (still needs protocol)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2612 r3151  
    2323
    2424#include "RpContour2D.h"
     25#include "RpVtkRenderer.h"
    2526#include "Trace.h"
    2627
    … …  
    2930Contour2D::Contour2D(int numContours) :
    3031    VtkGraphicsObject(),
    31     _numContours(numContours)
     32    _numContours(numContours),
     33    _colorMap(NULL),
     34    _colorMode(COLOR_CONSTANT),
     35    _colorFieldType(DataSet::POINT_DATA),
     36    _renderer(NULL)
    3237{
    3338    _edgeColor[0] = _color[0];
    3439    _edgeColor[1] = _color[0];
    3540    _edgeColor[2] = _color[0];
     41    _colorFieldRange[0] = DBL_MAX;
     42    _colorFieldRange[1] = -DBL_MAX;
    3643    _lighting = false;
    3744}
    … …  
    4047    VtkGraphicsObject(),
    4148    _numContours(contours.size()),
    42     _contours(contours)
     49    _contours(contours),
     50    _colorMap(NULL),
     51    _colorMode(COLOR_CONSTANT),
     52    _colorFieldType(DataSet::POINT_DATA),
     53    _renderer(NULL)
    4354{
    4455    _edgeColor[0] = _color[0];
    4556    _edgeColor[1] = _color[0];
    4657    _edgeColor[2] = _color[0];
     58    _colorFieldRange[0] = DBL_MAX;
     59    _colorFieldRange[1] = -DBL_MAX;
    4760    _lighting = false;
    4861}
    … …  
    5871}
    5972
     73void Contour2D::setDataSet(DataSet *dataSet,
     74                           Renderer *renderer)
     75{
     76    if (_dataSet != dataSet) {
     77        _dataSet = dataSet;
     78
     79        _renderer = renderer;
     80
     81        if (renderer->getUseCumulativeRange()) {
     82            renderer->getCumulativeDataRange(_dataRange,
     83                                             _dataSet->getActiveScalarsName(),
     84                                             1);
     85            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     86                                             _dataSet->getActiveVectorsName(),
     87                                             3);
     88            for (int i = 0; i < 3; i++) {
     89                renderer->getCumulativeDataRange(_vectorComponentRange[i],
     90                                                 _dataSet->getActiveVectorsName(),
     91                                                 3, i);
     92            }
     93        } else {
     94            _dataSet->getScalarRange(_dataRange);
     95            _dataSet->getVectorRange(_vectorMagnitudeRange);
     96            for (int i = 0; i < 3; i++) {
     97                _dataSet->getVectorRange(_vectorComponentRange[i], i);
     98            }
     99        }
     100
     101        update();
     102    }
     103}
     104
    60105/**
    61106 * \brief Internal method to re-compute contours after a state change
    … …  
    67112    }
    68113    vtkDataSet *ds = _dataSet->getVtkDataSet();
    69 
    70     initProp();
    71114
    72115    // Contour filter to generate isolines
    … …  
    166209        }
    167210    }
    168     if (_contourMapper == NULL) {
    169         _contourMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    170         _contourMapper->SetResolveCoincidentTopologyToPolygonOffset();
    171         _contourMapper->ScalarVisibilityOff();
     211
     212    initProp();
     213
     214    if (_dsMapper == NULL) {
     215        _dsMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     216        _dsMapper->SetResolveCoincidentTopologyToPolygonOffset();
     217        _dsMapper->ScalarVisibilityOff();
    172218        vtkSmartPointer<vtkStripper> stripper = vtkSmartPointer<vtkStripper>::New();
    173219        stripper->SetInputConnection(_contourFilter->GetOutputPort());
    174         _contourMapper->SetInputConnection(stripper->GetOutputPort());
    175         getActor()->SetMapper(_contourMapper);
    176     }
    177 
    178     _contourMapper->Update();
     220        _dsMapper->SetInputConnection(stripper->GetOutputPort());
     221        getActor()->SetMapper(_dsMapper);
     222    }
     223
     224    if (_lut == NULL) {
     225        setColorMap(ColorMap::getDefault());
     226    }
     227
     228    setColorMode(_colorMode);
     229
     230    _dsMapper->Update();
    179231}
    180232
    181233void Contour2D::updateRanges(Renderer *renderer)
    182234{
    183     VtkGraphicsObject::updateRanges(renderer);
     235    if (_dataSet == NULL) {
     236        ERROR("called before setDataSet");
     237        return;
     238    }
     239
     240    if (renderer->getUseCumulativeRange()) {
     241        renderer->getCumulativeDataRange(_dataRange,
     242                                         _dataSet->getActiveScalarsName(),
     243                                         1);
     244        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     245                                         _dataSet->getActiveVectorsName(),
     246                                         3);
     247        for (int i = 0; i < 3; i++) {
     248            renderer->getCumulativeDataRange(_vectorComponentRange[i],
     249                                             _dataSet->getActiveVectorsName(),
     250                                             3, i);
     251        }
     252    } else {
     253        _dataSet->getScalarRange(_dataRange);
     254        _dataSet->getVectorRange(_vectorMagnitudeRange);
     255        for (int i = 0; i < 3; i++) {
     256            _dataSet->getVectorRange(_vectorComponentRange[i], i);
     257        }
     258    }
    184259 
     260    // Need to update color map ranges
     261    double *rangePtr = _colorFieldRange;
     262    if (_colorFieldRange[0] > _colorFieldRange[1]) {
     263        rangePtr = NULL;
     264    }
     265    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
     266
    185267    if (_contours.empty() && _numContours > 0) {
    186268        // Contour isovalues need to be recomputed
    … …  
    189271}
    190272
     273void Contour2D::setColorMode(ColorMode mode)
     274{
     275    _colorMode = mode;
     276    if (_dataSet == NULL)
     277        return;
     278
     279    switch (mode) {
     280    case COLOR_BY_SCALAR:
     281        setColorMode(mode,
     282                     _dataSet->getActiveScalarsType(),
     283                     _dataSet->getActiveScalarsName(),
     284                     _dataRange);
     285        break;
     286    case COLOR_BY_VECTOR_MAGNITUDE:
     287        setColorMode(mode,
     288                     _dataSet->getActiveVectorsType(),
     289                     _dataSet->getActiveVectorsName(),
     290                     _vectorMagnitudeRange);
     291        break;
     292    case COLOR_BY_VECTOR_X:
     293        setColorMode(mode,
     294                     _dataSet->getActiveVectorsType(),
     295                     _dataSet->getActiveVectorsName(),
     296                     _vectorComponentRange[0]);
     297        break;
     298    case COLOR_BY_VECTOR_Y:
     299        setColorMode(mode,
     300                     _dataSet->getActiveVectorsType(),
     301                     _dataSet->getActiveVectorsName(),
     302                     _vectorComponentRange[1]);
     303        break;
     304    case COLOR_BY_VECTOR_Z:
     305        setColorMode(mode,
     306                     _dataSet->getActiveVectorsType(),
     307                     _dataSet->getActiveVectorsName(),
     308                     _vectorComponentRange[2]);
     309        break;
     310    case COLOR_CONSTANT:
     311    default:
     312        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
     313        break;
     314    }
     315}
     316
     317void Contour2D::setColorMode(ColorMode mode,
     318                             const char *name, double range[2])
     319{
     320    if (_dataSet == NULL)
     321        return;
     322    DataSet::DataAttributeType type = DataSet::POINT_DATA;
     323    int numComponents = 1;
     324    if (name != NULL && strlen(name) > 0 &&
     325        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
     326        ERROR("Field not found: %s", name);
     327        return;
     328    }
     329    setColorMode(mode, type, name, range);
     330}
     331
     332void Contour2D::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     333                             const char *name, double range[2])
     334{
     335    _colorMode = mode;
     336    _colorFieldType = type;
     337    if (name == NULL)
     338        _colorFieldName.clear();
     339    else
     340        _colorFieldName = name;
     341    if (range == NULL) {
     342        _colorFieldRange[0] = DBL_MAX;
     343        _colorFieldRange[1] = -DBL_MAX;
     344    } else {
     345        memcpy(_colorFieldRange, range, sizeof(double)*2);
     346    }
     347
     348    if (_dataSet == NULL || _dsMapper == NULL)
     349        return;
     350
     351    switch (type) {
     352    case DataSet::POINT_DATA:
     353        _dsMapper->SetScalarModeToUsePointFieldData();
     354        break;
     355    case DataSet::CELL_DATA:
     356        _dsMapper->SetScalarModeToUseCellFieldData();
     357        break;
     358    default:
     359        ERROR("Unsupported DataAttributeType: %d", type);
     360        return;
     361    }
     362
     363    if (name != NULL && strlen(name) > 0) {
     364        _dsMapper->SelectColorArray(name);
     365    } else {
     366        _dsMapper->SetScalarModeToDefault();
     367    }
     368
     369    if (_lut != NULL) {
     370        if (range != NULL) {
     371            _lut->SetRange(range);
     372        } else if (name != NULL && strlen(name) > 0) {
     373            double r[2];
     374            int comp = -1;
     375            if (mode == COLOR_BY_VECTOR_X)
     376                comp = 0;
     377            else if (mode == COLOR_BY_VECTOR_Y)
     378                comp = 1;
     379            else if (mode == COLOR_BY_VECTOR_Z)
     380                comp = 2;
     381
     382            if (_renderer->getUseCumulativeRange()) {
     383                int numComponents;
     384                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     385                    ERROR("Field not found: %s, type: %d", name, type);
     386                    return;
     387                } else if (numComponents < comp+1) {
     388                    ERROR("Request for component %d in field with %d components",
     389                          comp, numComponents);
     390                    return;
     391                }
     392                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     393            } else {
     394                _dataSet->getDataRange(r, name, type, comp);
     395            }
     396            _lut->SetRange(r);
     397        }
     398    }
     399
     400    switch (mode) {
     401    case COLOR_BY_SCALAR:
     402        _dsMapper->ScalarVisibilityOn();
     403        break;
     404    case COLOR_BY_VECTOR_MAGNITUDE:
     405        _dsMapper->ScalarVisibilityOn();
     406        if (_lut != NULL) {
     407            _lut->SetVectorModeToMagnitude();
     408        }
     409        break;
     410    case COLOR_BY_VECTOR_X:
     411        _dsMapper->ScalarVisibilityOn();
     412        if (_lut != NULL) {
     413            _lut->SetVectorModeToComponent();
     414            _lut->SetVectorComponent(0);
     415        }
     416        break;
     417    case COLOR_BY_VECTOR_Y:
     418        _dsMapper->ScalarVisibilityOn();
     419        if (_lut != NULL) {
     420            _lut->SetVectorModeToComponent();
     421            _lut->SetVectorComponent(1);
     422        }
     423        break;
     424    case COLOR_BY_VECTOR_Z:
     425        _dsMapper->ScalarVisibilityOn();
     426        if (_lut != NULL) {
     427            _lut->SetVectorModeToComponent();
     428            _lut->SetVectorComponent(2);
     429        }
     430        break;
     431    case COLOR_CONSTANT:
     432    default:
     433        _dsMapper->ScalarVisibilityOff();
     434        break;
     435    }
     436}
     437
     438/**
     439 * \brief Called when the color map has been edited
     440 */
     441void Contour2D::updateColorMap()
     442{
     443    setColorMap(_colorMap);
     444}
     445
     446/**
     447 * \brief Associate a colormap lookup table with the DataSet
     448 */
     449void Contour2D::setColorMap(ColorMap *cmap)
     450{
     451    if (cmap == NULL)
     452        return;
     453
     454    _colorMap = cmap;
     455 
     456    if (_lut == NULL) {
     457        _lut = vtkSmartPointer<vtkLookupTable>::New();
     458        if (_dsMapper != NULL) {
     459            _dsMapper->UseLookupTableScalarRangeOn();
     460            _dsMapper->SetLookupTable(_lut);
     461        }
     462        _lut->DeepCopy(cmap->getLookupTable());
     463        switch (_colorMode) {
     464        case COLOR_CONSTANT:
     465        case COLOR_BY_SCALAR:
     466            _lut->SetRange(_dataRange);
     467            break;
     468        case COLOR_BY_VECTOR_MAGNITUDE:
     469            _lut->SetRange(_vectorMagnitudeRange);
     470            break;
     471        case COLOR_BY_VECTOR_X:
     472            _lut->SetRange(_vectorComponentRange[0]);
     473            break;
     474        case COLOR_BY_VECTOR_Y:
     475            _lut->SetRange(_vectorComponentRange[1]);
     476            break;
     477        case COLOR_BY_VECTOR_Z:
     478            _lut->SetRange(_vectorComponentRange[2]);
     479            break;
     480        default:
     481            break;
     482        }
     483    } else {
     484        double range[2];
     485        _lut->GetTableRange(range);
     486        _lut->DeepCopy(cmap->getLookupTable());
     487        _lut->SetRange(range);
     488    }
     489
     490    switch (_colorMode) {
     491    case COLOR_BY_VECTOR_MAGNITUDE:
     492        _lut->SetVectorModeToMagnitude();
     493        break;
     494    case COLOR_BY_VECTOR_X:
     495        _lut->SetVectorModeToComponent();
     496        _lut->SetVectorComponent(0);
     497        break;
     498    case COLOR_BY_VECTOR_Y:
     499        _lut->SetVectorModeToComponent();
     500        _lut->SetVectorComponent(1);
     501        break;
     502    case COLOR_BY_VECTOR_Z:
     503        _lut->SetVectorModeToComponent();
     504        _lut->SetVectorComponent(2);
     505        break;
     506    default:
     507         break;
     508    }
     509}
     510
    191511/**
    192512 * \brief Specify number of evenly spaced contour lines to render
    … …  
    239559void Contour2D::setClippingPlanes(vtkPlaneCollection *planes)
    240560{
    241     if (_contourMapper != NULL) {
    242         _contourMapper->SetClippingPlanes(planes);
    243     }
    244 }
     561    if (_dsMapper != NULL) {
     562        _dsMapper->SetClippingPlanes(planes);
     563    }
     564}
Note: See TracChangeset for help on using the changeset viewer.