Changeset 3490


Ignore:
Timestamp:
Mar 11, 2013, 9:03:35 PM (12 years ago)
Author:
ldelgass
Message:

Bring contour2d/3d code in vtkvis more in line with heightmap, make setting
number of contours/contour list faster.

Location:
trunk/packages/vizservers/vtkvis
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r3330 r3490  
    3232    VtkGraphicsObject(),
    3333    _numContours(numContours),
     34    _pipelineInitialized(false),
    3435    _colorMap(NULL),
    3536    _colorMode(COLOR_BY_SCALAR),
    … …  
    4950    _numContours(contours.size()),
    5051    _contours(contours),
     52    _pipelineInitialized(false),
    5153    _colorMap(NULL),
    5254    _colorMode(COLOR_BY_SCALAR),
    … …  
    7779    if (_dataSet != dataSet) {
    7880        _dataSet = dataSet;
    79 
    8081        _renderer = renderer;
    8182
    … …  
    8485                                             _dataSet->getActiveScalarsName(),
    8586                                             1);
     87            const char *activeVectors = _dataSet->getActiveVectorsName();
     88            if (activeVectors != NULL) {
     89                renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     90                                                 _dataSet->getActiveVectorsName(),
     91                                                 3);
     92                for (int i = 0; i < 3; i++) {
     93                    renderer->getCumulativeDataRange(_vectorComponentRange[i],
     94                                                     _dataSet->getActiveVectorsName(),
     95                                                     3, i);
     96                }
     97            }
     98        } else {
     99            _dataSet->getScalarRange(_dataRange);
     100            _dataSet->getVectorRange(_vectorMagnitudeRange);
     101            for (int i = 0; i < 3; i++) {
     102                _dataSet->getVectorRange(_vectorComponentRange[i], i);
     103            }
     104        }
     105
     106        update();
     107    }
     108}
     109
     110/**
     111 * \brief Internal method to re-compute contours after a state change
     112 */
     113void Contour2D::update()
     114{
     115    if (_dataSet == NULL) {
     116        return;
     117    }
     118    vtkDataSet *ds = _dataSet->getVtkDataSet();
     119
     120    // Contour filter to generate isolines
     121    if (_contourFilter == NULL) {
     122        _contourFilter = vtkSmartPointer<vtkContourFilter>::New();
     123    }
     124
     125    if (!_pipelineInitialized) {
     126        vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
     127
     128        if (ds->GetPointData() == NULL ||
     129            ds->GetPointData()->GetScalars() == NULL) {
     130            WARN("No scalar point data in dataset %s", _dataSet->getName().c_str());
     131            if (ds->GetCellData() != NULL &&
     132                ds->GetCellData()->GetScalars() != NULL) {
     133                cellToPtData =
     134                    vtkSmartPointer<vtkCellDataToPointData>::New();
     135#ifdef USE_VTK6
     136                cellToPtData->SetInputData(ds);
     137#else
     138                cellToPtData->SetInput(ds);
     139#endif
     140                //cellToPtData->PassCellDataOn();
     141                cellToPtData->Update();
     142                ds = cellToPtData->GetOutput();
     143            } else {
     144                ERROR("No scalar cell data in dataset %s", _dataSet->getName().c_str());
     145            }
     146        }
     147
     148        vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
     149        if (pd) {
     150            // DataSet is a vtkPolyData
     151            if (pd->GetNumberOfLines() == 0 &&
     152                pd->GetNumberOfPolys() == 0 &&
     153                pd->GetNumberOfStrips() == 0) {
     154                // DataSet is a point cloud
     155                PrincipalPlane plane;
     156                double offset;
     157                if (_dataSet->is2D(&plane, &offset)) {
     158                    vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
     159                    if (plane == PLANE_ZY) {
     160                        vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     161                        trans->RotateWXYZ(90, 0, 1, 0);
     162                        if (offset != 0.0) {
     163                            trans->Translate(-offset, 0, 0);
     164                        }
     165                        mesher->SetTransform(trans);
     166                    } else if (plane == PLANE_XZ) {
     167                        vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     168                        trans->RotateWXYZ(-90, 1, 0, 0);
     169                        if (offset != 0.0) {
     170                            trans->Translate(0, -offset, 0);
     171                        }
     172                        mesher->SetTransform(trans);
     173                    } else if (offset != 0.0) {
     174                        // XY with Z offset
     175                        vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     176                        trans->Translate(0, 0, -offset);
     177                        mesher->SetTransform(trans);
     178                    }
     179#ifdef USE_VTK6
     180                    mesher->SetInputData(pd);
     181#else
     182                    mesher->SetInput(pd);
     183#endif
     184                    _contourFilter->SetInputConnection(mesher->GetOutputPort());
     185                } else {
     186                    vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     187#ifdef USE_VTK6
     188                    mesher->SetInputData(pd);
     189#else
     190                    mesher->SetInput(pd);
     191#endif
     192                    vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     193                    gf->SetInputConnection(mesher->GetOutputPort());
     194                    _contourFilter->SetInputConnection(gf->GetOutputPort());
     195                }
     196            } else {
     197                // DataSet is a vtkPolyData with lines and/or polygons
     198#ifdef USE_VTK6
     199                _contourFilter->SetInputData(ds);
     200#else
     201                _contourFilter->SetInput(ds);
     202#endif
     203            }
     204        } else {
     205            TRACE("Generating surface for data set");
     206            // DataSet is NOT a vtkPolyData
     207            vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     208#ifdef USE_VTK6
     209            gf->SetInputData(ds);
     210#else
     211            gf->SetInput(ds);
     212#endif
     213            _contourFilter->SetInputConnection(gf->GetOutputPort());
     214        }
     215    }
     216
     217    _pipelineInitialized = true;
     218
     219    _contourFilter->ComputeNormalsOff();
     220    _contourFilter->ComputeGradientsOff();
     221
     222    // Speed up multiple contour computation at cost of extra memory use
     223    if (_numContours > 1) {
     224        _contourFilter->UseScalarTreeOn();
     225    } else {
     226        _contourFilter->UseScalarTreeOff();
     227    }
     228
     229    _contourFilter->SetNumberOfContours(_numContours);
     230
     231    if (_contours.empty()) {
     232        // Evenly spaced isovalues
     233        _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
     234    } else {
     235        // User-supplied isovalues
     236        for (int i = 0; i < _numContours; i++) {
     237            _contourFilter->SetValue(i, _contours[i]);
     238        }
     239    }
     240
     241    initProp();
     242
     243    if (_dsMapper == NULL) {
     244        _dsMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     245        _dsMapper->SetResolveCoincidentTopologyToPolygonOffset();
     246        _dsMapper->ScalarVisibilityOff();
     247        vtkSmartPointer<vtkStripper> stripper = vtkSmartPointer<vtkStripper>::New();
     248        stripper->SetInputConnection(_contourFilter->GetOutputPort());
     249        _dsMapper->SetInputConnection(stripper->GetOutputPort());
     250        getActor()->SetMapper(_dsMapper);
     251    }
     252
     253    if (_lut == NULL) {
     254        setColorMap(ColorMap::getDefault());
     255        setColorMode(_colorMode);
     256    }
     257
     258    _dsMapper->Update();
     259}
     260
     261void Contour2D::updateRanges(Renderer *renderer)
     262{
     263    if (_dataSet == NULL) {
     264        ERROR("called before setDataSet");
     265        return;
     266    }
     267
     268    if (renderer->getUseCumulativeRange()) {
     269        renderer->getCumulativeDataRange(_dataRange,
     270                                         _dataSet->getActiveScalarsName(),
     271                                         1);
     272        const char *activeVectors = _dataSet->getActiveVectorsName();
     273        if (activeVectors != NULL) {
    86274            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
    87275                                             _dataSet->getActiveVectorsName(),
    … …  
    92280                                                 3, i);
    93281            }
    94         } else {
    95             _dataSet->getScalarRange(_dataRange);
    96             _dataSet->getVectorRange(_vectorMagnitudeRange);
    97             for (int i = 0; i < 3; i++) {
    98                 _dataSet->getVectorRange(_vectorComponentRange[i], i);
    99             }
    100         }
    101 
    102         update();
    103     }
    104 }
    105 
    106 /**
    107  * \brief Internal method to re-compute contours after a state change
    108  */
    109 void Contour2D::update()
    110 {
    111     if (_dataSet == NULL) {
    112         return;
    113     }
    114     vtkDataSet *ds = _dataSet->getVtkDataSet();
    115 
    116     // Contour filter to generate isolines
    117     if (_contourFilter == NULL) {
    118         _contourFilter = vtkSmartPointer<vtkContourFilter>::New();
    119     }
    120 
    121     vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
    122 
    123     if (ds->GetPointData() == NULL ||
    124         ds->GetPointData()->GetScalars() == NULL) {
    125         WARN("No scalar point data in dataset %s", _dataSet->getName().c_str());
    126         if (ds->GetCellData() != NULL &&
    127             ds->GetCellData()->GetScalars() != NULL) {
    128             cellToPtData =
    129                 vtkSmartPointer<vtkCellDataToPointData>::New();
    130 #ifdef USE_VTK6
    131             cellToPtData->SetInputData(ds);
    132 #else
    133             cellToPtData->SetInput(ds);
    134 #endif
    135             //cellToPtData->PassCellDataOn();
    136             cellToPtData->Update();
    137             ds = cellToPtData->GetOutput();
    138         } else {
    139             ERROR("No scalar cell data in dataset %s", _dataSet->getName().c_str());
    140         }
    141     }
    142 
    143     vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
    144     if (pd) {
    145         // DataSet is a vtkPolyData
    146         if (pd->GetNumberOfLines() == 0 &&
    147             pd->GetNumberOfPolys() == 0 &&
    148             pd->GetNumberOfStrips() == 0) {
    149             // DataSet is a point cloud
    150             PrincipalPlane plane;
    151             double offset;
    152             if (_dataSet->is2D(&plane, &offset)) {
    153                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    154                 if (plane == PLANE_ZY) {
    155                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    156                     trans->RotateWXYZ(90, 0, 1, 0);
    157                     if (offset != 0.0) {
    158                         trans->Translate(-offset, 0, 0);
    159                     }
    160                     mesher->SetTransform(trans);
    161                 } else if (plane == PLANE_XZ) {
    162                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    163                     trans->RotateWXYZ(-90, 1, 0, 0);
    164                     if (offset != 0.0) {
    165                         trans->Translate(0, -offset, 0);
    166                     }
    167                     mesher->SetTransform(trans);
    168                 } else if (offset != 0.0) {
    169                     // XY with Z offset
    170                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    171                     trans->Translate(0, 0, -offset);
    172                     mesher->SetTransform(trans);
    173                 }
    174 #ifdef USE_VTK6
    175                 mesher->SetInputData(pd);
    176 #else
    177                 mesher->SetInput(pd);
    178 #endif
    179                 _contourFilter->SetInputConnection(mesher->GetOutputPort());
    180             } else {
    181                 vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
    182 #ifdef USE_VTK6
    183                 mesher->SetInputData(pd);
    184 #else
    185                 mesher->SetInput(pd);
    186 #endif
    187                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    188                 gf->SetInputConnection(mesher->GetOutputPort());
    189                 _contourFilter->SetInputConnection(gf->GetOutputPort());
    190             }
    191         } else {
    192             // DataSet is a vtkPolyData with lines and/or polygons
    193 #ifdef USE_VTK6
    194             _contourFilter->SetInputData(ds);
    195 #else
    196             _contourFilter->SetInput(ds);
    197 #endif
    198         }
    199     } else {
    200         TRACE("Generating surface for data set");
    201         // DataSet is NOT a vtkPolyData
    202         vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    203 #ifdef USE_VTK6
    204         gf->SetInputData(ds);
    205 #else
    206         gf->SetInput(ds);
    207 #endif
    208         _contourFilter->SetInputConnection(gf->GetOutputPort());
    209     }
    210 
    211     _contourFilter->ComputeNormalsOff();
    212     _contourFilter->ComputeGradientsOff();
    213 
    214     // Speed up multiple contour computation at cost of extra memory use
    215     if (_numContours > 1) {
    216         _contourFilter->UseScalarTreeOn();
    217     } else {
    218         _contourFilter->UseScalarTreeOff();
    219     }
    220 
    221     _contourFilter->SetNumberOfContours(_numContours);
    222 
    223     if (_contours.empty()) {
    224         // Evenly spaced isovalues
    225         _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
    226     } else {
    227         // User-supplied isovalues
    228         for (int i = 0; i < _numContours; i++) {
    229             _contourFilter->SetValue(i, _contours[i]);
    230         }
    231     }
    232 
    233     initProp();
    234 
    235     if (_dsMapper == NULL) {
    236         _dsMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    237         _dsMapper->SetResolveCoincidentTopologyToPolygonOffset();
    238         _dsMapper->ScalarVisibilityOff();
    239         vtkSmartPointer<vtkStripper> stripper = vtkSmartPointer<vtkStripper>::New();
    240         stripper->SetInputConnection(_contourFilter->GetOutputPort());
    241         _dsMapper->SetInputConnection(stripper->GetOutputPort());
    242         getActor()->SetMapper(_dsMapper);
    243     }
    244 
    245     if (_lut == NULL) {
    246         setColorMap(ColorMap::getDefault());
    247     }
    248 
    249     setColorMode(_colorMode);
    250 
    251     _dsMapper->Update();
    252 }
    253 
    254 void Contour2D::updateRanges(Renderer *renderer)
    255 {
    256     if (_dataSet == NULL) {
    257         ERROR("called before setDataSet");
    258         return;
    259     }
    260 
    261     if (renderer->getUseCumulativeRange()) {
    262         renderer->getCumulativeDataRange(_dataRange,
    263                                          _dataSet->getActiveScalarsName(),
    264                                          1);
    265         renderer->getCumulativeDataRange(_vectorMagnitudeRange,
    266                                          _dataSet->getActiveVectorsName(),
    267                                          3);
    268         for (int i = 0; i < 3; i++) {
    269             renderer->getCumulativeDataRange(_vectorComponentRange[i],
    270                                              _dataSet->getActiveVectorsName(),
    271                                              3, i);
    272282        }
    273283    } else {
    … …  
    536546 * Will override any existing contours
    537547 */
    538 void Contour2D::setContours(int numContours)
     548void Contour2D::setNumContours(int numContours)
    539549{
    540550    _contours.clear();

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

    r3177 r3490  
    5454    virtual void setClippingPlanes(vtkPlaneCollection *planes);
    5555
    56     void setContours(int numContours);
     56    void setNumContours(int numContours);
    5757
    5858    void setContourList(const std::vector<double>& contours);
    … …  
    103103    std::vector<double> _contours;
    104104
     105    bool _pipelineInitialized;
     106
    105107    ColorMap *_colorMap;
    106108    ColorMode _colorMode;

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

    r3330 r3490  
    3030    VtkGraphicsObject(),
    3131    _numContours(numContours),
     32    _pipelineInitialized(false),
    3233    _colorMap(NULL),
    3334    _colorMode(COLOR_BY_SCALAR),
    … …  
    4243    VtkGraphicsObject(),
    4344    _numContours(contours.size()),
     45    _pipelineInitialized(false),
    4446    _contours(contours),
    4547    _colorMap(NULL),
    … …  
    6769    if (_dataSet != dataSet) {
    6870        _dataSet = dataSet;
    69 
    7071        _renderer = renderer;
    7172
    … …  
    7475                                             _dataSet->getActiveScalarsName(),
    7576                                             1);
     77            const char *activeVectors = _dataSet->getActiveVectorsName();
     78            if (activeVectors != NULL) {
     79                renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     80                                                 _dataSet->getActiveVectorsName(),
     81                                                 3);
     82                for (int i = 0; i < 3; i++) {
     83                    renderer->getCumulativeDataRange(_vectorComponentRange[i],
     84                                                     _dataSet->getActiveVectorsName(),
     85                                                     3, i);
     86                }
     87            }
     88        } else {
     89            _dataSet->getScalarRange(_dataRange);
     90            _dataSet->getVectorRange(_vectorMagnitudeRange);
     91            for (int i = 0; i < 3; i++) {
     92                _dataSet->getVectorRange(_vectorComponentRange[i], i);
     93            }
     94        }
     95
     96        update();
     97    }
     98}
     99
     100/**
     101 * \brief Internal method to re-compute contours after a state change
     102 */
     103void Contour3D::update()
     104{
     105    if (_dataSet == NULL) {
     106        return;
     107    }
     108    vtkDataSet *ds = _dataSet->getVtkDataSet();
     109
     110    if (_dataSet->is2D()) {
     111        ERROR("DataSet is 2D");
     112        return;
     113    }
     114
     115    // Contour filter to generate isosurfaces
     116    if (_contourFilter == NULL) {
     117        _contourFilter = vtkSmartPointer<vtkContourFilter>::New();
     118    }
     119
     120    if (!_pipelineInitialized) {
     121        vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
     122
     123        if (ds->GetPointData() == NULL ||
     124            ds->GetPointData()->GetScalars() == NULL) {
     125            WARN("No scalar point data in dataset %s", _dataSet->getName().c_str());
     126            if (ds->GetCellData() != NULL &&
     127                ds->GetCellData()->GetScalars() != NULL) {
     128                cellToPtData =
     129                    vtkSmartPointer<vtkCellDataToPointData>::New();
     130#ifdef USE_VTK6
     131                cellToPtData->SetInputData(ds);
     132#else
     133                cellToPtData->SetInput(ds);
     134#endif
     135                //cellToPtData->PassCellDataOn();
     136                cellToPtData->Update();
     137                ds = cellToPtData->GetOutput();
     138            } else {
     139                ERROR("No scalar cell data in dataset %s", _dataSet->getName().c_str());
     140            }
     141        }
     142
     143        vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
     144        if (pd) {
     145            // DataSet is a vtkPolyData
     146            if (pd->GetNumberOfLines() == 0 &&
     147                pd->GetNumberOfPolys() == 0 &&
     148                pd->GetNumberOfStrips() == 0) {
     149                // DataSet is a point cloud
     150                // Generate a 3D unstructured grid
     151                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     152#ifdef USE_VTK6
     153                mesher->SetInputData(pd);
     154#else
     155                mesher->SetInput(pd);
     156#endif
     157                _contourFilter->SetInputConnection(mesher->GetOutputPort());
     158            } else {
     159                // DataSet is a vtkPolyData with lines and/or polygons
     160                ERROR("Not a 3D DataSet");
     161                return;
     162            }
     163        } else {
     164            // DataSet is NOT a vtkPolyData
     165#ifdef USE_VTK6
     166            _contourFilter->SetInputData(ds);
     167#else
     168            _contourFilter->SetInput(ds);
     169#endif
     170        }
     171    }
     172
     173    _pipelineInitialized = true;
     174
     175    _contourFilter->ComputeNormalsOff();
     176    _contourFilter->ComputeGradientsOff();
     177
     178    // Speed up multiple contour computation at cost of extra memory use
     179    if (_numContours > 1) {
     180        _contourFilter->UseScalarTreeOn();
     181    } else {
     182        _contourFilter->UseScalarTreeOff();
     183    }
     184
     185    _contourFilter->SetNumberOfContours(_numContours);
     186
     187    if (_contours.empty()) {
     188        // Evenly spaced isovalues
     189        _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
     190    } else {
     191        // User-supplied isovalues
     192        for (int i = 0; i < _numContours; i++) {
     193            _contourFilter->SetValue(i, _contours[i]);
     194        }
     195    }
     196
     197    initProp();
     198
     199    if (_normalsGenerator == NULL) {
     200        _normalsGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
     201        _normalsGenerator->SetInputConnection(_contourFilter->GetOutputPort());
     202        _normalsGenerator->SetFeatureAngle(90.);
     203        _normalsGenerator->AutoOrientNormalsOff();
     204        _normalsGenerator->ComputePointNormalsOn();
     205    }
     206
     207    if (_dsMapper == NULL) {
     208        _dsMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     209        _dsMapper->SetResolveCoincidentTopologyToPolygonOffset();
     210        _dsMapper->SetInputConnection(_normalsGenerator->GetOutputPort());
     211        _dsMapper->ScalarVisibilityOff();
     212        //_dsMapper->SetColorModeToMapScalars();
     213        getActor()->SetMapper(_dsMapper);
     214    }
     215
     216    if (_lut == NULL) {
     217        setColorMap(ColorMap::getDefault());
     218        setColorMode(_colorMode);
     219    }
     220
     221    _dsMapper->Update();
     222    TRACE("Contour output %d polys, %d strips",
     223          _contourFilter->GetOutput()->GetNumberOfPolys(),
     224          _contourFilter->GetOutput()->GetNumberOfStrips());
     225}
     226
     227void Contour3D::updateRanges(Renderer *renderer)
     228{
     229    if (_dataSet == NULL) {
     230        ERROR("called before setDataSet");
     231        return;
     232    }
     233
     234    if (renderer->getUseCumulativeRange()) {
     235        renderer->getCumulativeDataRange(_dataRange,
     236                                         _dataSet->getActiveScalarsName(),
     237                                         1);
     238        const char *activeVectors = _dataSet->getActiveVectorsName();
     239        if (activeVectors != NULL) {
    76240            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
    77241                                             _dataSet->getActiveVectorsName(),
    … …  
    82246                                                 3, i);
    83247            }
    84         } else {
    85             _dataSet->getScalarRange(_dataRange);
    86             _dataSet->getVectorRange(_vectorMagnitudeRange);
    87             for (int i = 0; i < 3; i++) {
    88                 _dataSet->getVectorRange(_vectorComponentRange[i], i);
    89             }
    90         }
    91 
    92         update();
    93     }
    94 }
    95 
    96 /**
    97  * \brief Internal method to re-compute contours after a state change
    98  */
    99 void Contour3D::update()
    100 {
    101     if (_dataSet == NULL) {
    102         return;
    103     }
    104     vtkDataSet *ds = _dataSet->getVtkDataSet();
    105 
    106     if (_dataSet->is2D()) {
    107         ERROR("DataSet is 2D");
    108         return;
    109     }
    110 
    111     // Contour filter to generate isosurfaces
    112     if (_contourFilter == NULL) {
    113         _contourFilter = vtkSmartPointer<vtkContourFilter>::New();
    114     }
    115 
    116     vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
    117 
    118     if (ds->GetPointData() == NULL ||
    119         ds->GetPointData()->GetScalars() == NULL) {
    120         WARN("No scalar point data in dataset %s", _dataSet->getName().c_str());
    121         if (ds->GetCellData() != NULL &&
    122             ds->GetCellData()->GetScalars() != NULL) {
    123             cellToPtData =
    124                 vtkSmartPointer<vtkCellDataToPointData>::New();
    125 #ifdef USE_VTK6
    126             cellToPtData->SetInputData(ds);
    127 #else
    128             cellToPtData->SetInput(ds);
    129 #endif
    130             //cellToPtData->PassCellDataOn();
    131             cellToPtData->Update();
    132             ds = cellToPtData->GetOutput();
    133         } else {
    134             ERROR("No scalar cell data in dataset %s", _dataSet->getName().c_str());
    135         }
    136     }
    137 
    138     vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
    139     if (pd) {
    140         // DataSet is a vtkPolyData
    141         if (pd->GetNumberOfLines() == 0 &&
    142             pd->GetNumberOfPolys() == 0 &&
    143             pd->GetNumberOfStrips() == 0) {
    144             // DataSet is a point cloud
    145             // Generate a 3D unstructured grid
    146             vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
    147 #ifdef USE_VTK6
    148             mesher->SetInputData(pd);
    149 #else
    150             mesher->SetInput(pd);
    151 #endif
    152             _contourFilter->SetInputConnection(mesher->GetOutputPort());
    153         } else {
    154             // DataSet is a vtkPolyData with lines and/or polygons
    155             ERROR("Not a 3D DataSet");
    156             return;
    157         }
    158     } else {
    159          // DataSet is NOT a vtkPolyData
    160 #ifdef USE_VTK6
    161          _contourFilter->SetInputData(ds);
    162 #else
    163          _contourFilter->SetInput(ds);
    164 #endif
    165     }
    166 
    167     _contourFilter->ComputeNormalsOff();
    168     _contourFilter->ComputeGradientsOff();
    169 
    170     // Speed up multiple contour computation at cost of extra memory use
    171     if (_numContours > 1) {
    172         _contourFilter->UseScalarTreeOn();
    173     } else {
    174         _contourFilter->UseScalarTreeOff();
    175     }
    176 
    177     _contourFilter->SetNumberOfContours(_numContours);
    178 
    179     if (_contours.empty()) {
    180         // Evenly spaced isovalues
    181         _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
    182     } else {
    183         // User-supplied isovalues
    184         for (int i = 0; i < _numContours; i++) {
    185             _contourFilter->SetValue(i, _contours[i]);
    186         }
    187     }
    188 
    189     initProp();
    190 
    191     if (_normalsGenerator == NULL) {
    192         _normalsGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
    193     }
    194 
    195     _normalsGenerator->SetInputConnection(_contourFilter->GetOutputPort());
    196     _normalsGenerator->SetFeatureAngle(90.);
    197     _normalsGenerator->AutoOrientNormalsOff();
    198     _normalsGenerator->ComputePointNormalsOn();
    199 
    200     if (_dsMapper == NULL) {
    201         _dsMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    202         _dsMapper->SetResolveCoincidentTopologyToPolygonOffset();
    203         _dsMapper->SetInputConnection(_normalsGenerator->GetOutputPort());
    204         _dsMapper->ScalarVisibilityOff();
    205         //_dsMapper->SetColorModeToMapScalars();
    206         getActor()->SetMapper(_dsMapper);
    207     }
    208 
    209     if (_lut == NULL) {
    210         setColorMap(ColorMap::getDefault());
    211     }
    212 
    213     setColorMode(_colorMode);
    214 
    215     _dsMapper->Update();
    216     TRACE("Contour output %d polys, %d strips",
    217           _contourFilter->GetOutput()->GetNumberOfPolys(),
    218           _contourFilter->GetOutput()->GetNumberOfStrips());
    219 }
    220 
    221 void Contour3D::updateRanges(Renderer *renderer)
    222 {
    223     if (_dataSet == NULL) {
    224         ERROR("called before setDataSet");
    225         return;
    226     }
    227 
    228     if (renderer->getUseCumulativeRange()) {
    229         renderer->getCumulativeDataRange(_dataRange,
    230                                          _dataSet->getActiveScalarsName(),
    231                                          1);
    232         renderer->getCumulativeDataRange(_vectorMagnitudeRange,
    233                                          _dataSet->getActiveVectorsName(),
    234                                          3);
    235         for (int i = 0; i < 3; i++) {
    236             renderer->getCumulativeDataRange(_vectorComponentRange[i],
    237                                              _dataSet->getActiveVectorsName(),
    238                                              3, i);
    239248        }
    240249    } else {
    … …  
    503512 * Will override any existing contours
    504513 */
    505 void Contour3D::setContours(int numContours)
     514void Contour3D::setNumContours(int numContours)
    506515{
    507516    _contours.clear();

  • trunk/packages/vizservers/vtkvis/RpContour3D.h

    r3330 r3490  
    5555    virtual void setClippingPlanes(vtkPlaneCollection *planes);
    5656
    57     void setContours(int numContours);
     57    void setNumContours(int numContours);
    5858
    5959    void setContourList(const std::vector<double>& contours);
    … …  
    9393    std::vector<double> _contours;
    9494
     95    bool _pipelineInitialized;
     96
    9597    ColorMap *_colorMap;
    9698    ColorMode _colorMode;

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

    r3435 r3490  
    9797        _renderer = renderer;
    9898
    99         TRACE("DataSet name: '%s' type: %s",
    100               _dataSet->getName().c_str(),
    101               _dataSet->getVtkType());
    102 
    10399        if (_dataSet != NULL) {
     100            TRACE("DataSet name: '%s' type: %s",
     101                  _dataSet->getName().c_str(),
     102                  _dataSet->getVtkType());
     103
    104104            if (renderer->getUseCumulativeRange()) {
    105105                renderer->getCumulativeDataRange(_dataRange,

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

    r3419 r3490  
    573573    bool addContour2D(const DataSetId& id, const std::vector<double>& contours);
    574574
    575     void setContour2DContours(const DataSetId& id, int numContours);
     575    void setContour2DNumContours(const DataSetId& id, int numContours);
    576576
    577577    void setContour2DContourList(const DataSetId& id, const std::vector<double>& contours);
    … …  
    592592    bool addContour3D(const DataSetId& id, const std::vector<double>& contours);
    593593
    594     void setContour3DContours(const DataSetId& id, int numContours);
     594    void setContour3DNumContours(const DataSetId& id, int numContours);
    595595
    596596    void setContour3DContourList(const DataSetId& id, const std::vector<double>& contours);

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

    r3488 r3490  
    28802880    if (objc == 4) {
    28812881        const char *name = Tcl_GetString(objv[3]);
    2882         g_renderer->setContour2DContours(name, numContours);
    2883     } else {
    2884         g_renderer->setContour2DContours("all", numContours);
     2882        g_renderer->setContour2DNumContours(name, numContours);
     2883    } else {
     2884        g_renderer->setContour2DNumContours("all", numContours);
    28852885    }
    28862886    return TCL_OK;
    … …  
    32843284    if (objc == 4) {
    32853285        const char *name = Tcl_GetString(objv[3]);
    3286         g_renderer->setContour3DContours(name, numContours);
    3287     } else {
    3288         g_renderer->setContour3DContours("all", numContours);
     3286        g_renderer->setContour3DNumContours(name, numContours);
     3287    } else {
     3288        g_renderer->setContour3DNumContours("all", numContours);
    32893289    }
    32903290    return TCL_OK;

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

    r3330 r3490  
    554554 * \brief Set the number of equally spaced contour isolines for the given DataSet
    555555 */
    556 void Renderer::setContour2DContours(const DataSetId& id, int numContours)
     556void Renderer::setContour2DNumContours(const DataSetId& id, int numContours)
    557557{
    558558    Contour2DHashmap::iterator itr;
    … …  
    572572
    573573    do {
    574         itr->second->setContours(numContours);
     574        itr->second->setNumContours(numContours);
    575575    } while (doAll && ++itr != _contour2Ds.end());
    576576
    … …  
    767767 * \brief Set the number of equally spaced isosurfaces for the given DataSet
    768768 */
    769 void Renderer::setContour3DContours(const DataSetId& id, int numContours)
     769void Renderer::setContour3DNumContours(const DataSetId& id, int numContours)
    770770{
    771771    Contour3DHashmap::iterator itr;
    … …  
    785785
    786786    do {
    787         itr->second->setContours(numContours);
     787        itr->second->setNumContours(numContours);
    788788     } while (doAll && ++itr != _contour3Ds.end());
    789789
Note: See TracChangeset for help on using the changeset viewer.