Changeset 3818


Ignore:
Timestamp:
Jul 18, 2013 2:51:21 PM (7 years ago)
Author:
ldelgass
Message:

Add colormode for PolyData?, by default color map if an active scalar field with
multiple components is present (color scalars). Add protocol for image/text3d
drawing components. Make 'color' synonym for 'ccolor' in protocol commands,
also accept 'ccolor' or 'constant' as colormode. Add experimental commands for
simple legend (no field info required), extended colormode for heightmap with
explicit range. Add fontconfig support (needs testing). Added code to remove
duplicate points from unstructured grids. Should probably be optional. Stack
trace on error (if WANT_TRACE is on) using VTK.

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

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/vtkvis/DataSet.cpp

    r3710 r3818  
    2424#include <vtkCell.h>
    2525#include <vtkLookupTable.h>
     26#include <vtkExtractUnstructuredGrid.h>
    2627
    2728#include "DataSet.h"
     
    145146}
    146147
    147 void DataSet::print() const
    148 {
    149     print(_dataSet);
    150 }
    151 
    152 void DataSet::print(vtkDataSet *ds)
    153 {
    154     if (ds == NULL)
    155         return;
    156 
    157     TRACE("DataSet class: %s", ds->GetClassName());
    158 
    159     TRACE("DataSet memory: %g MiB", ds->GetActualMemorySize()/1024.);
    160 
    161     double bounds[6];
    162     ds->GetBounds(bounds);
    163 
    164     // Topology
    165     TRACE("DataSet bounds: %g %g %g %g %g %g",
    166           bounds[0], bounds[1],
    167           bounds[2], bounds[3],
    168           bounds[4], bounds[5]);
    169     TRACE("Points: %d Cells: %d", ds->GetNumberOfPoints(), ds->GetNumberOfCells());
    170 
    171     double dataRange[2];
    172     if (ds->GetPointData() != NULL) {
    173         TRACE("PointData arrays: %d", ds->GetPointData()->GetNumberOfArrays());
    174         for (int i = 0; i < ds->GetPointData()->GetNumberOfArrays(); i++) {
    175             if (ds->GetPointData()->GetArray(i) != NULL) {
    176                 ds->GetPointData()->GetArray(i)->GetRange(dataRange, -1);
    177                 TRACE("PointData[%d]: '%s' comp:%d, (%g,%g)", i,
    178                       ds->GetPointData()->GetArrayName(i),
    179                       ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents(),
    180                       dataRange[0], dataRange[1]);
    181             } else {
    182                 TRACE("PointData[%d]: '%s' comp:%d", i,
    183                       ds->GetPointData()->GetArrayName(i),
    184                       ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents());
    185             }
    186         }
    187         if (ds->GetPointData()->GetScalars() != NULL) {
    188             TRACE("Active point scalars: %s", ds->GetPointData()->GetScalars()->GetName());
    189         }
    190         if (ds->GetPointData()->GetVectors() != NULL) {
    191             TRACE("Active point vectors: %s", ds->GetPointData()->GetVectors()->GetName());
    192         }
    193     }
    194     if (ds->GetCellData() != NULL) {
    195         TRACE("CellData arrays: %d", ds->GetCellData()->GetNumberOfArrays());
    196         for (int i = 0; i < ds->GetCellData()->GetNumberOfArrays(); i++) {
    197             if (ds->GetCellData()->GetArray(i) != NULL) {
    198                 ds->GetCellData()->GetArray(i)->GetRange(dataRange, -1);
    199                 TRACE("CellData[%d]: '%s' comp:%d, (%g,%g)", i,
    200                       ds->GetCellData()->GetArrayName(i),
    201                       ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents(),
    202                       dataRange[0], dataRange[1]);
    203             } else {
    204                 TRACE("CellData[%d]: '%s' comp:%d", i,
    205                       ds->GetCellData()->GetArrayName(i),
    206                       ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents());
    207             }
    208         }
    209         if (ds->GetCellData()->GetScalars() != NULL) {
    210             TRACE("Active cell scalars: %s", ds->GetCellData()->GetScalars()->GetName());
    211         }
    212         if (ds->GetCellData()->GetVectors() != NULL) {
    213             TRACE("Active cell vectors: %s", ds->GetCellData()->GetVectors()->GetName());
    214         }
    215     }
    216     if (ds->GetFieldData() != NULL) {
    217         TRACE("FieldData arrays: %d", ds->GetFieldData()->GetNumberOfArrays());
    218         for (int i = 0; i < ds->GetFieldData()->GetNumberOfArrays(); i++) {
    219             if (ds->GetFieldData()->GetArray(i) != NULL) {
    220                 ds->GetFieldData()->GetArray(i)->GetRange(dataRange, -1);
    221                 TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d (%g,%g)", i,
    222                       ds->GetFieldData()->GetArrayName(i),
    223                       ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
    224                       ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples(),
    225                       dataRange[0], dataRange[1]);
    226             } else {
    227                 TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d", i,
    228                       ds->GetFieldData()->GetArrayName(i),
    229                       ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
    230                       ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples());
    231             }
    232         }
    233     }
    234 }
    235 
    236 void DataSet::setDefaultArrays()
    237 {
    238     if (_dataSet->GetPointData() != NULL &&
    239         _dataSet->GetPointData()->GetScalars() == NULL &&
    240         _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
    241         for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
    242             if (_dataSet->GetPointData()->GetArray(i) != NULL &&
    243                 _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 1) {
    244                 TRACE("Setting point scalars to '%s'", _dataSet->GetPointData()->GetArrayName(i));
    245                 _dataSet->GetPointData()->SetActiveScalars(_dataSet->GetPointData()->GetArrayName(i));
    246                 break;
    247             }
    248         }
    249     }
    250     if (_dataSet->GetPointData() != NULL &&
    251         _dataSet->GetPointData()->GetVectors() == NULL &&
    252         _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
    253         for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
    254             if (_dataSet->GetPointData()->GetArray(i) != NULL &&
    255                 _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 3) {
    256                 TRACE("Setting point vectors to '%s'", _dataSet->GetPointData()->GetArrayName(i));
    257                 _dataSet->GetPointData()->SetActiveVectors(_dataSet->GetPointData()->GetArrayName(i));
    258                 break;
    259             }
    260         }
    261     }
    262     if (_dataSet->GetCellData() != NULL &&
    263         _dataSet->GetCellData()->GetScalars() == NULL &&
    264         _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
    265         for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
    266             if (_dataSet->GetCellData()->GetArray(i) != NULL &&
    267                 _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 1) {
    268                 TRACE("Setting cell scalars to '%s'", _dataSet->GetCellData()->GetArrayName(i));
    269                 _dataSet->GetCellData()->SetActiveScalars(_dataSet->GetCellData()->GetArrayName(i));
    270                 break;
    271             }
    272         }
    273     }
    274     if (_dataSet->GetCellData() != NULL &&
    275         _dataSet->GetCellData()->GetVectors() == NULL &&
    276         _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
    277         for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
    278             if (_dataSet->GetCellData()->GetArray(i) != NULL &&
    279                 _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 3) {
    280                 TRACE("Setting cell vectors to '%s'", _dataSet->GetCellData()->GetArrayName(i));
    281                 _dataSet->GetCellData()->SetActiveVectors(_dataSet->GetCellData()->GetArrayName(i));
    282                 break;
    283             }
    284         }
    285     }
    286 }
    287 
    288148/**
    289149 * \brief Read dataset using supplied reader
     
    303163    if (_dataSet == NULL)
    304164        return false;
     165
     166    if (vtkUnstructuredGrid::SafeDownCast(_dataSet) != NULL) {
     167        vtkSmartPointer<vtkExtractUnstructuredGrid> filter = vtkSmartPointer<vtkExtractUnstructuredGrid>::New();
     168#ifdef USE_VTK6
     169        filter->SetInputData(_dataSet);
     170#else
     171        filter->SetInput(_dataSet);
     172#endif
     173        filter->MergingOn();
     174        filter->ReleaseDataFlagOn();
     175        filter->Update();
     176        _dataSet = filter->GetOutput();
     177    }
     178
    305179#ifndef USE_VTK6
    306180    _dataSet->SetPipelineInformation(NULL);
     
    652526    }
    653527    return NULL;
     528}
     529
     530void DataSet::setDefaultArrays()
     531{
     532    if (_dataSet->GetPointData() != NULL &&
     533        _dataSet->GetPointData()->GetScalars() == NULL &&
     534        _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
     535        for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
     536            if (_dataSet->GetPointData()->GetArray(i) != NULL &&
     537                _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 1) {
     538                TRACE("Setting point scalars to '%s'", _dataSet->GetPointData()->GetArrayName(i));
     539                _dataSet->GetPointData()->SetActiveScalars(_dataSet->GetPointData()->GetArrayName(i));
     540                break;
     541            }
     542        }
     543    }
     544    if (_dataSet->GetPointData() != NULL &&
     545        _dataSet->GetPointData()->GetVectors() == NULL &&
     546        _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
     547        for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
     548            if (_dataSet->GetPointData()->GetArray(i) != NULL &&
     549                _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 3) {
     550                TRACE("Setting point vectors to '%s'", _dataSet->GetPointData()->GetArrayName(i));
     551                _dataSet->GetPointData()->SetActiveVectors(_dataSet->GetPointData()->GetArrayName(i));
     552                break;
     553            }
     554        }
     555    }
     556    if (_dataSet->GetCellData() != NULL &&
     557        _dataSet->GetCellData()->GetScalars() == NULL &&
     558        _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
     559        for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
     560            if (_dataSet->GetCellData()->GetArray(i) != NULL &&
     561                _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 1) {
     562                TRACE("Setting cell scalars to '%s'", _dataSet->GetCellData()->GetArrayName(i));
     563                _dataSet->GetCellData()->SetActiveScalars(_dataSet->GetCellData()->GetArrayName(i));
     564                break;
     565            }
     566        }
     567    }
     568    if (_dataSet->GetCellData() != NULL &&
     569        _dataSet->GetCellData()->GetVectors() == NULL &&
     570        _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
     571        for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
     572            if (_dataSet->GetCellData()->GetArray(i) != NULL &&
     573                _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 3) {
     574                TRACE("Setting cell vectors to '%s'", _dataSet->GetCellData()->GetArrayName(i));
     575                _dataSet->GetCellData()->SetActiveVectors(_dataSet->GetCellData()->GetArrayName(i));
     576                break;
     577            }
     578        }
     579    }
    654580}
    655581
     
    973899    return true;
    974900}
     901
     902void DataSet::print() const
     903{
     904    print(_dataSet);
     905}
     906
     907void DataSet::print(vtkDataSet *ds)
     908{
     909    if (ds == NULL)
     910        return;
     911
     912    TRACE("DataSet class: %s", ds->GetClassName());
     913
     914    TRACE("DataSet memory: %g MiB", ds->GetActualMemorySize()/1024.);
     915
     916    double bounds[6];
     917    ds->GetBounds(bounds);
     918
     919    // Topology
     920    TRACE("DataSet bounds: %g %g %g %g %g %g",
     921          bounds[0], bounds[1],
     922          bounds[2], bounds[3],
     923          bounds[4], bounds[5]);
     924    TRACE("Points: %d Cells: %d", ds->GetNumberOfPoints(), ds->GetNumberOfCells());
     925
     926    double dataRange[2];
     927    if (ds->GetPointData() != NULL) {
     928        TRACE("PointData arrays: %d", ds->GetPointData()->GetNumberOfArrays());
     929        for (int i = 0; i < ds->GetPointData()->GetNumberOfArrays(); i++) {
     930            if (ds->GetPointData()->GetArray(i) != NULL) {
     931                ds->GetPointData()->GetArray(i)->GetRange(dataRange, -1);
     932                TRACE("PointData[%d]: '%s' comp:%d, (%g,%g)", i,
     933                      ds->GetPointData()->GetArrayName(i),
     934                      ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents(),
     935                      dataRange[0], dataRange[1]);
     936            } else {
     937                TRACE("PointData[%d]: '%s' comp:%d", i,
     938                      ds->GetPointData()->GetArrayName(i),
     939                      ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents());
     940            }
     941        }
     942        if (ds->GetPointData()->GetScalars() != NULL) {
     943            TRACE("Active point scalars: %s", ds->GetPointData()->GetScalars()->GetName());
     944        }
     945        if (ds->GetPointData()->GetVectors() != NULL) {
     946            TRACE("Active point vectors: %s", ds->GetPointData()->GetVectors()->GetName());
     947        }
     948    }
     949    if (ds->GetCellData() != NULL) {
     950        TRACE("CellData arrays: %d", ds->GetCellData()->GetNumberOfArrays());
     951        for (int i = 0; i < ds->GetCellData()->GetNumberOfArrays(); i++) {
     952            if (ds->GetCellData()->GetArray(i) != NULL) {
     953                ds->GetCellData()->GetArray(i)->GetRange(dataRange, -1);
     954                TRACE("CellData[%d]: '%s' comp:%d, (%g,%g)", i,
     955                      ds->GetCellData()->GetArrayName(i),
     956                      ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents(),
     957                      dataRange[0], dataRange[1]);
     958            } else {
     959                TRACE("CellData[%d]: '%s' comp:%d", i,
     960                      ds->GetCellData()->GetArrayName(i),
     961                      ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents());
     962            }
     963        }
     964        if (ds->GetCellData()->GetScalars() != NULL) {
     965            TRACE("Active cell scalars: %s", ds->GetCellData()->GetScalars()->GetName());
     966        }
     967        if (ds->GetCellData()->GetVectors() != NULL) {
     968            TRACE("Active cell vectors: %s", ds->GetCellData()->GetVectors()->GetName());
     969        }
     970    }
     971    if (ds->GetFieldData() != NULL) {
     972        TRACE("FieldData arrays: %d", ds->GetFieldData()->GetNumberOfArrays());
     973        for (int i = 0; i < ds->GetFieldData()->GetNumberOfArrays(); i++) {
     974            if (ds->GetFieldData()->GetArray(i) != NULL) {
     975                ds->GetFieldData()->GetArray(i)->GetRange(dataRange, -1);
     976                TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d (%g,%g)", i,
     977                      ds->GetFieldData()->GetArrayName(i),
     978                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
     979                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples(),
     980                      dataRange[0], dataRange[1]);
     981            } else {
     982                TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d", i,
     983                      ds->GetFieldData()->GetArrayName(i),
     984                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
     985                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples());
     986            }
     987        }
     988    }
     989}
     990
  • trunk/packages/vizservers/vtkvis/DataSet.h

    r3680 r3818  
    2626class DataSet {
    2727public:
     28    /**
     29     * These enum values intentionally match vtkDataObject::FieldAssociations
     30     * and vtkDataObject::AttributeTypes
     31     */
    2832    enum DataAttributeType {
    2933        POINT_DATA,
  • trunk/packages/vizservers/vtkvis/HeightMap.cpp

    r3680 r3818  
    478478    if (_contours.empty()) {
    479479        // Evenly spaced isovalues
    480         _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
     480        if (_colorFieldRange[0] <= _colorFieldRange[1]) {
     481            _contourFilter->GenerateValues(_numContours, _colorFieldRange[0], _colorFieldRange[1]);
     482        } else {
     483            _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
     484        }
    481485    } else {
    482486        // User-supplied isovalues
  • trunk/packages/vizservers/vtkvis/Makefile.in

    r3797 r3818  
    22TRACE                   = #yes
    33USE_CUSTOM_AXES         = yes
     4USE_FONT_CONFIG         = #yes
    45USE_GPU_RAYCASTING      = yes
    56USE_OFFSCREEN_RENDERING = #yes
     
    121122DEFINES         += -DUSE_CUSTOM_AXES
    122123endif
     124ifdef USE_FONT_CONFIG
     125DEFINES         += -DUSE_FONT_CONFIG
     126endif
    123127ifdef USE_OFFSCREEN_RENDERING
    124128DEFINES         += -DUSE_OFFSCREEN_RENDERING
  • trunk/packages/vizservers/vtkvis/PolyData.cpp

    r3777 r3818  
    2222#include <vtkDataSetSurfaceFilter.h>
    2323#include <vtkVertexGlyphFilter.h>
     24#include <vtkLookupTable.h>
    2425
    2526#include "PolyData.h"
     27#include "Renderer.h"
    2628#include "Trace.h"
    2729
     
    3032PolyData::PolyData() :
    3133    GraphicsObject(),
     34    _colorMap(NULL),
     35    _colorMode(COLOR_CONSTANT),
     36    _colorFieldType(DataSet::POINT_DATA),
     37    _renderer(NULL),
    3238    _cloudStyle(CLOUD_MESH)
    3339{
     40    _colorFieldRange[0] = DBL_MAX;
     41    _colorFieldRange[1] = -DBL_MAX;
    3442}
    3543
     
    4250        TRACE("Deleting PolyData with NULL DataSet");
    4351#endif
     52}
     53
     54void PolyData::setDataSet(DataSet *dataSet,
     55                          Renderer *renderer)
     56{
     57    if (_dataSet != dataSet) {
     58        _dataSet = dataSet;
     59
     60        _renderer = renderer;
     61
     62        if (renderer->getUseCumulativeRange()) {
     63            renderer->getCumulativeDataRange(_dataRange,
     64                                             _dataSet->getActiveScalarsName(),
     65                                             1);
     66            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     67                                             _dataSet->getActiveVectorsName(),
     68                                             3);
     69            for (int i = 0; i < 3; i++) {
     70                renderer->getCumulativeDataRange(_vectorComponentRange[i],
     71                                                 _dataSet->getActiveVectorsName(),
     72                                                 3, i);
     73            }
     74        } else {
     75            _dataSet->getScalarRange(_dataRange);
     76            _dataSet->getVectorRange(_vectorMagnitudeRange);
     77            for (int i = 0; i < 3; i++) {
     78                _dataSet->getVectorRange(_vectorComponentRange[i], i);
     79            }
     80        }
     81
     82        update();
     83    }
    4484}
    4585
     
    211251    }
    212252
     253    setInterpolateBeforeMapping(false);
     254
     255    if (_lut == NULL) {
     256        setColorMap(ColorMap::getDefault());
     257        if (_dataSet->getActiveScalarsName() != NULL) {
     258            int numComp;
     259            _dataSet->getFieldInfo(_dataSet->getActiveScalarsName(),
     260                                   _dataSet->getActiveScalarsType(),
     261                                   &numComp);
     262            if (numComp > 1) {
     263                setColorMode(COLOR_BY_SCALAR);
     264            } else {
     265                setColorMode(_colorMode);
     266            }
     267        } else {
     268            setColorMode(_colorMode);
     269        }
     270    } else {
     271        double *rangePtr = _colorFieldRange;
     272        if (_colorFieldRange[0] > _colorFieldRange[1]) {
     273            rangePtr = NULL;
     274        }
     275        setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
     276    }
     277
    213278    initProp();
    214279    getActor()->SetMapper(_mapper);
     
    220285}
    221286
     287void PolyData::setInterpolateBeforeMapping(bool state)
     288{
     289    if (_mapper != NULL) {
     290        _mapper->SetInterpolateScalarsBeforeMapping((state ? 1 : 0));
     291    }
     292}
     293
     294void PolyData::updateRanges(Renderer *renderer)
     295{
     296    if (_dataSet == NULL) {
     297        ERROR("called before setDataSet");
     298        return;
     299    }
     300
     301    if (renderer->getUseCumulativeRange()) {
     302        renderer->getCumulativeDataRange(_dataRange,
     303                                         _dataSet->getActiveScalarsName(),
     304                                         1);
     305        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     306                                         _dataSet->getActiveVectorsName(),
     307                                         3);
     308        for (int i = 0; i < 3; i++) {
     309            renderer->getCumulativeDataRange(_vectorComponentRange[i],
     310                                             _dataSet->getActiveVectorsName(),
     311                                             3, i);
     312        }
     313    } else {
     314        _dataSet->getScalarRange(_dataRange);
     315        _dataSet->getVectorRange(_vectorMagnitudeRange);
     316        for (int i = 0; i < 3; i++) {
     317            _dataSet->getVectorRange(_vectorComponentRange[i], i);
     318        }
     319    }
     320
     321    // Need to update color map ranges
     322    double *rangePtr = _colorFieldRange;
     323    if (_colorFieldRange[0] > _colorFieldRange[1]) {
     324        rangePtr = NULL;
     325    }
     326    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
     327}
     328
     329void PolyData::setColorMode(ColorMode mode)
     330{
     331    _colorMode = mode;
     332    if (_dataSet == NULL)
     333        return;
     334
     335    switch (mode) {
     336    case COLOR_BY_SCALAR:
     337        setColorMode(mode,
     338                     _dataSet->getActiveScalarsType(),
     339                     _dataSet->getActiveScalarsName(),
     340                     _dataRange);
     341        break;
     342    case COLOR_BY_VECTOR_MAGNITUDE:
     343        setColorMode(mode,
     344                     _dataSet->getActiveVectorsType(),
     345                     _dataSet->getActiveVectorsName(),
     346                     _vectorMagnitudeRange);
     347        break;
     348    case COLOR_BY_VECTOR_X:
     349        setColorMode(mode,
     350                     _dataSet->getActiveVectorsType(),
     351                     _dataSet->getActiveVectorsName(),
     352                     _vectorComponentRange[0]);
     353        break;
     354    case COLOR_BY_VECTOR_Y:
     355        setColorMode(mode,
     356                     _dataSet->getActiveVectorsType(),
     357                     _dataSet->getActiveVectorsName(),
     358                     _vectorComponentRange[1]);
     359        break;
     360    case COLOR_BY_VECTOR_Z:
     361        setColorMode(mode,
     362                     _dataSet->getActiveVectorsType(),
     363                     _dataSet->getActiveVectorsName(),
     364                     _vectorComponentRange[2]);
     365        break;
     366    case COLOR_CONSTANT:
     367    default:
     368        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
     369        break;
     370    }
     371}
     372
     373void PolyData::setColorMode(ColorMode mode,
     374                            const char *name, double range[2])
     375{
     376    if (_dataSet == NULL)
     377        return;
     378    DataSet::DataAttributeType type = DataSet::POINT_DATA;
     379    int numComponents = 1;
     380    if (name != NULL && strlen(name) > 0 &&
     381        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
     382        ERROR("Field not found: %s", name);
     383        return;
     384    }
     385    setColorMode(mode, type, name, range);
     386}
     387
     388void PolyData::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     389                            const char *name, double range[2])
     390{
     391    _colorMode = mode;
     392    _colorFieldType = type;
     393    if (name == NULL)
     394        _colorFieldName.clear();
     395    else
     396        _colorFieldName = name;
     397    if (range == NULL) {
     398        _colorFieldRange[0] = DBL_MAX;
     399        _colorFieldRange[1] = -DBL_MAX;
     400    } else {
     401        memcpy(_colorFieldRange, range, sizeof(double)*2);
     402    }
     403
     404    if (_dataSet == NULL || _mapper == NULL)
     405        return;
     406
     407    switch (type) {
     408    case DataSet::POINT_DATA:
     409        _mapper->SetScalarModeToUsePointFieldData();
     410        break;
     411    case DataSet::CELL_DATA:
     412        _mapper->SetScalarModeToUseCellFieldData();
     413        break;
     414    case DataSet::FIELD_DATA:
     415        _mapper->SetScalarModeToUseFieldData();
     416        break;
     417    default:
     418        ERROR("Unsupported DataAttributeType: %d", type);
     419        return;
     420    }
     421
     422    if (name != NULL && strlen(name) > 0) {
     423        _mapper->SelectColorArray(name);
     424    } else {
     425        _mapper->SetScalarModeToDefault();
     426    }
     427
     428    if (_lut != NULL) {
     429        if (range != NULL) {
     430            _lut->SetRange(range);
     431        } else if (name != NULL && strlen(name) > 0) {
     432            double r[2];
     433            int comp = -1;
     434            if (mode == COLOR_BY_VECTOR_X)
     435                comp = 0;
     436            else if (mode == COLOR_BY_VECTOR_Y)
     437                comp = 1;
     438            else if (mode == COLOR_BY_VECTOR_Z)
     439                comp = 2;
     440
     441            if (_renderer->getUseCumulativeRange()) {
     442                int numComponents;
     443                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     444                    ERROR("Field not found: %s, type: %d", name, type);
     445                    return;
     446                } else if (numComponents < comp+1) {
     447                    ERROR("Request for component %d in field with %d components",
     448                          comp, numComponents);
     449                    return;
     450                }
     451                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     452            } else {
     453                _dataSet->getDataRange(r, name, type, comp);
     454            }
     455            _lut->SetRange(r);
     456        }
     457    }
     458
     459    switch (mode) {
     460    case COLOR_BY_SCALAR:
     461        _mapper->ScalarVisibilityOn();
     462        break;
     463    case COLOR_BY_VECTOR_MAGNITUDE:
     464        _mapper->ScalarVisibilityOn();
     465        if (_lut != NULL) {
     466            _lut->SetVectorModeToMagnitude();
     467        }
     468        break;
     469    case COLOR_BY_VECTOR_X:
     470        _mapper->ScalarVisibilityOn();
     471        if (_lut != NULL) {
     472            _lut->SetVectorModeToComponent();
     473            _lut->SetVectorComponent(0);
     474        }
     475        break;
     476    case COLOR_BY_VECTOR_Y:
     477        _mapper->ScalarVisibilityOn();
     478        if (_lut != NULL) {
     479            _lut->SetVectorModeToComponent();
     480            _lut->SetVectorComponent(1);
     481        }
     482        break;
     483    case COLOR_BY_VECTOR_Z:
     484        _mapper->ScalarVisibilityOn();
     485        if (_lut != NULL) {
     486            _lut->SetVectorModeToComponent();
     487            _lut->SetVectorComponent(2);
     488        }
     489        break;
     490    case COLOR_CONSTANT:
     491    default:
     492        _mapper->ScalarVisibilityOff();
     493        break;
     494    }
     495}
     496
     497/**
     498 * \brief Called when the color map has been edited
     499 */
     500void PolyData::updateColorMap()
     501{
     502    setColorMap(_colorMap);
     503}
     504
     505/**
     506 * \brief Associate a colormap lookup table with the DataSet
     507 */
     508void PolyData::setColorMap(ColorMap *cmap)
     509{
     510    if (cmap == NULL)
     511        return;
     512
     513    _colorMap = cmap;
     514 
     515    if (_lut == NULL) {
     516        _lut = vtkSmartPointer<vtkLookupTable>::New();
     517        if (_mapper != NULL) {
     518            _mapper->UseLookupTableScalarRangeOn();
     519            _mapper->SetLookupTable(_lut);
     520        }
     521        _lut->DeepCopy(cmap->getLookupTable());
     522        switch (_colorMode) {
     523        case COLOR_CONSTANT:
     524        case COLOR_BY_SCALAR:
     525            _lut->SetRange(_dataRange);
     526            break;
     527        case COLOR_BY_VECTOR_MAGNITUDE:
     528            _lut->SetRange(_vectorMagnitudeRange);
     529            break;
     530        case COLOR_BY_VECTOR_X:
     531            _lut->SetRange(_vectorComponentRange[0]);
     532            break;
     533        case COLOR_BY_VECTOR_Y:
     534            _lut->SetRange(_vectorComponentRange[1]);
     535            break;
     536        case COLOR_BY_VECTOR_Z:
     537            _lut->SetRange(_vectorComponentRange[2]);
     538            break;
     539        default:
     540            break;
     541        }
     542    } else {
     543        double range[2];
     544        _lut->GetTableRange(range);
     545        _lut->DeepCopy(cmap->getLookupTable());
     546        _lut->SetRange(range);
     547        _lut->Modified();
     548    }
     549
     550    switch (_colorMode) {
     551    case COLOR_BY_VECTOR_MAGNITUDE:
     552        _lut->SetVectorModeToMagnitude();
     553        break;
     554    case COLOR_BY_VECTOR_X:
     555        _lut->SetVectorModeToComponent();
     556        _lut->SetVectorComponent(0);
     557        break;
     558    case COLOR_BY_VECTOR_Y:
     559        _lut->SetVectorModeToComponent();
     560        _lut->SetVectorComponent(1);
     561        break;
     562    case COLOR_BY_VECTOR_Z:
     563        _lut->SetVectorModeToComponent();
     564        _lut->SetVectorComponent(2);
     565        break;
     566    default:
     567         break;
     568    }
     569}
     570
    222571/**
    223572 * \brief Set a group of world coordinate planes to clip rendering
  • trunk/packages/vizservers/vtkvis/PolyData.h

    r3774 r3818  
    1212#include <vtkPolyDataMapper.h>
    1313#include <vtkActor.h>
     14#include <vtkLookupTable.h>
    1415
     16#include "ColorMap.h"
    1517#include "GraphicsObject.h"
    16 #include "DataSet.h"
    1718
    1819namespace VtkVis {
     
    2930        CLOUD_POINTS
    3031    };
     32    enum ColorMode {
     33        COLOR_BY_SCALAR,
     34        COLOR_BY_VECTOR_MAGNITUDE,
     35        COLOR_BY_VECTOR_X,
     36        COLOR_BY_VECTOR_Y,
     37        COLOR_BY_VECTOR_Z,
     38        COLOR_CONSTANT
     39    };
    3140
    3241    PolyData();
     
    3847    }
    3948
     49    virtual void setDataSet(DataSet *dataSet,
     50                            Renderer *renderer);
     51
    4052    virtual void setClippingPlanes(vtkPlaneCollection *planes);
    4153
    4254    void setCloudStyle(CloudStyle style);
    4355
     56    void setInterpolateBeforeMapping(bool state);
     57
     58    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     59                      const char *name, double range[2] = NULL);
     60
     61    void setColorMode(ColorMode mode,
     62                      const char *name, double range[2] = NULL);
     63
     64    void setColorMode(ColorMode mode);
     65
     66    void setColorMap(ColorMap *colorMap);
     67
     68    /**
     69     * \brief Return the ColorMap in use
     70     */
     71    ColorMap *getColorMap()
     72    {
     73        return _colorMap;
     74    }
     75
     76    void updateColorMap();
     77
     78    virtual void updateRanges(Renderer *renderer);
     79
    4480private:
    4581    virtual void update();
    4682
     83    ColorMap *_colorMap;
     84    ColorMode _colorMode;
     85    std::string _colorFieldName;
     86    DataSet::DataAttributeType _colorFieldType;
     87    double _colorFieldRange[2];
     88    double _vectorMagnitudeRange[2];
     89    double _vectorComponentRange[3][2];
     90    Renderer *_renderer;
     91
    4792    CloudStyle _cloudStyle;
     93    vtkSmartPointer<vtkLookupTable> _lut;
    4894    vtkSmartPointer<vtkPolyDataMapper> _mapper;
    4995};
  • trunk/packages/vizservers/vtkvis/PseudoColor.cpp

    r3774 r3818  
    387387        _mapper->SetScalarModeToUseCellFieldData();
    388388        break;
     389    case DataSet::FIELD_DATA:
     390        _mapper->SetScalarModeToUseFieldData();
     391        break;
    389392    default:
    390393        ERROR("Unsupported DataAttributeType: %d", type);
     
    394397    if (_splatter != NULL) {
    395398        if (name != NULL && strlen(name) > 0) {
    396             _splatter->SetInputArrayToProcess(0, 0, 0, vtkDataObject::FIELD_ASSOCIATION_POINTS, name);
     399            _splatter->SetInputArrayToProcess(0, 0, 0, type, name);
    397400        }
    398401        _mapper->SelectColorArray("SplatterValues");
  • trunk/packages/vizservers/vtkvis/RenderServer.cpp

    r3621 r3818  
    2222
    2323#include <tcl.h>
     24
     25#include <vtksys/SystemInformation.hxx>
    2426
    2527#include "Trace.h"
     
    494496    TRACE("Starting VTKVis Server");
    495497
     498#ifdef WANT_TRACE
     499    vtksys::SystemInformation::SetStackTraceOnError(1);
     500#endif
     501
    496502    /* This synchronizes the client with the server, so that the client
    497503     * doesn't start writing commands before the server is ready. It could
  • trunk/packages/vizservers/vtkvis/Renderer.cpp

    r3797 r3818  
    1717#endif
    1818
     19#ifdef USE_FONT_CONFIG
     20#include <vtkFreeTypeTools.h>
     21#endif
    1922#include <vtkMath.h>
    2023#include <vtkCamera.h>
     
    118121    if (_cameraMode == IMAGE)
    119122        _activeClipPlanes->AddItem(_cameraClipPlanes[3]);
     123
     124#ifdef USE_FONT_CONFIG
     125    vtkFreeTypeTools *typeTools = vtkFreeTypeTools::GetInstance();
     126    typeTools->ForceCompiledFontsOff();
     127    TRACE("FreeTypeTools impl: %s", typeTools->GetClassName());
     128#endif
     129
    120130    _renderer = vtkSmartPointer<vtkRenderer>::New();
    121131
     
    182192    deleteAllGraphicsObjects<Group>();
    183193    deleteAllGraphicsObjects<HeightMap>();
     194    deleteAllGraphicsObjects<Image>();
    184195    deleteAllGraphicsObjects<LIC>();
    185196    deleteAllGraphicsObjects<Line>();
     
    191202    deleteAllGraphicsObjects<Sphere>();
    192203    deleteAllGraphicsObjects<Streamlines>();
     204    deleteAllGraphicsObjects<Text3D>();
    193205    deleteAllGraphicsObjects<Volume>();
    194206    deleteAllGraphicsObjects<Warp>();
     
    262274        deleteGraphicsObject<Glyphs>(itr->second->getName());
    263275        deleteGraphicsObject<HeightMap>(itr->second->getName());
     276        deleteGraphicsObject<Image>(itr->second->getName());
    264277        deleteGraphicsObject<LIC>(itr->second->getName());
    265278        deleteGraphicsObject<Molecule>(itr->second->getName());
     
    15531566    updateGraphicsObjectColorMap<Glyphs>(cmap);
    15541567    updateGraphicsObjectColorMap<HeightMap>(cmap);
     1568    updateGraphicsObjectColorMap<Image>(cmap);
    15551569    updateGraphicsObjectColorMap<LIC>(cmap);
    15561570    updateGraphicsObjectColorMap<Molecule>(cmap);
     1571    updateGraphicsObjectColorMap<PolyData>(cmap);
    15571572    updateGraphicsObjectColorMap<PseudoColor>(cmap);
    15581573    updateGraphicsObjectColorMap<Streamlines>(cmap);
     
    15771592    if (graphicsObjectColorMapUsed<HeightMap>(cmap))
    15781593        return true;
     1594    if (graphicsObjectColorMapUsed<Image>(cmap))
     1595        return true;
    15791596    if (graphicsObjectColorMapUsed<LIC>(cmap))
    15801597        return true;
    15811598    if (graphicsObjectColorMapUsed<Molecule>(cmap))
     1599        return true;
     1600    if (graphicsObjectColorMapUsed<PolyData>(cmap))
    15821601        return true;
    15831602    if (graphicsObjectColorMapUsed<PseudoColor>(cmap))
     
    21782197}
    21792198
     2199bool Renderer::renderColorMap(const ColorMapId& id,
     2200                              int width, int height,
     2201                              bool opaque,
     2202                              vtkUnsignedCharArray *imgData)
     2203{
     2204    TRACE("Enter");
     2205    ColorMap *colorMap = getColorMap(id);
     2206    if (colorMap == NULL)
     2207        return false;
     2208
     2209    if (_legendRenderWindow == NULL) {
     2210        _legendRenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
     2211        _legendRenderWindow->SetMultiSamples(0);
     2212#ifdef USE_OFFSCREEN_RENDERING
     2213        _legendRenderWindow->DoubleBufferOff();
     2214        _legendRenderWindow->OffScreenRenderingOn();
     2215#else
     2216        _legendRenderWindow->DoubleBufferOn();
     2217        _legendRenderWindow->SwapBuffersOff();
     2218#endif
     2219    }
     2220
     2221    _legendRenderWindow->SetSize(width, height);
     2222
     2223    if (_legendRenderer == NULL) {
     2224        _legendRenderer = vtkSmartPointer<vtkRenderer>::New();
     2225        _legendRenderWindow->AddRenderer(_legendRenderer);
     2226    }
     2227    _legendRenderer->SetBackground(_bgColor[0], _bgColor[1], _bgColor[2]);
     2228
     2229    if (_scalarBarActor == NULL) {
     2230        _scalarBarActor = vtkSmartPointer<vtkScalarBarActor>::New();
     2231        _scalarBarActor->DrawFrameOff();
     2232        _scalarBarActor->DrawBackgroundOff();
     2233        _scalarBarActor->DrawColorBarOn();
     2234        _legendRenderer->AddViewProp(_scalarBarActor);
     2235    }
     2236
     2237    if (opaque) {
     2238        _scalarBarActor->UseOpacityOff();
     2239    } else {
     2240        _scalarBarActor->UseOpacityOn();
     2241    }
     2242
     2243    if (width > height) {
     2244        _scalarBarActor->SetOrientationToHorizontal();
     2245    } else {
     2246        _scalarBarActor->SetOrientationToVertical();
     2247    }
     2248
     2249    // Set viewport-relative width/height/pos
     2250#ifdef NEW_SCALAR_BAR
     2251    _scalarBarActor->SetBarRatio(1);
     2252    _scalarBarActor->SetTitleRatio(0);
     2253#endif
     2254    if (width > height) {
     2255        // horizontal
     2256#ifdef NEW_SCALAR_BAR
     2257        _scalarBarActor->SetDisplayPosition(0, 0);
     2258        _scalarBarActor->GetPosition2Coordinate()->SetCoordinateSystemToDisplay();
     2259        _scalarBarActor->GetPosition2Coordinate()->SetValue(width+4, height);
     2260#else
     2261        _scalarBarActor->SetPosition(0, 0);
     2262        _scalarBarActor->SetHeight((((double)height+1.5)/((double)height))/0.4); // VTK: floor(actorHeight * .4)
     2263        _scalarBarActor->SetWidth(1); // VTK: actorWidth
     2264#endif
     2265    } else {
     2266        // vertical
     2267#ifdef NEW_SCALAR_BAR
     2268        _scalarBarActor->SetDisplayPosition(0, -4);
     2269        _scalarBarActor->GetPosition2Coordinate()->SetCoordinateSystemToDisplay();
     2270        _scalarBarActor->GetPosition2Coordinate()->SetValue(width+1, height+5);
     2271#else
     2272        _scalarBarActor->SetPosition(0, 0);
     2273        _scalarBarActor->SetHeight((((double)height+1.5)/((double)height))/0.86); // VTK: floor(actorHeight * .86)
     2274        _scalarBarActor->SetWidth(((double)(width+5))/((double)width)); // VTK: actorWidth - 4 pixels
     2275#endif
     2276    }
     2277
     2278    vtkSmartPointer<vtkLookupTable> lut = colorMap->getLookupTable();
     2279
     2280    double range[2];
     2281    range[0] = 0.0;
     2282    range[1] = 1.0;
     2283
     2284    lut->SetRange(range);
     2285
     2286    _scalarBarActor->SetLookupTable(lut);
     2287    _scalarBarActor->SetMaximumNumberOfColors((width > height ? width : height));
     2288    _scalarBarActor->SetTitle("");
     2289    _scalarBarActor->SetNumberOfLabels(0);
     2290#ifdef NEW_SCALAR_BAR
     2291    _scalarBarActor->DrawAnnotationsOff();
     2292    _scalarBarActor->SetAnnotationLeaderPadding(0);
     2293    _scalarBarActor->SetTextPad(0);
     2294#endif
     2295
     2296    _legendRenderWindow->Render();
     2297
     2298#ifdef RENDER_TARGA
     2299    _legendRenderWindow->MakeCurrent();
     2300    // Must clear previous errors first.
     2301    while (glGetError() != GL_NO_ERROR){
     2302        ;
     2303    }
     2304    int bytesPerPixel = TARGA_BYTES_PER_PIXEL;
     2305    int size = bytesPerPixel * width * height;
     2306
     2307    if (imgData->GetMaxId() + 1 != size)
     2308    {
     2309        imgData->SetNumberOfComponents(bytesPerPixel);
     2310        imgData->SetNumberOfValues(size);
     2311    }
     2312    glDisable(GL_TEXTURE_2D);
     2313    if (_legendRenderWindow->GetDoubleBuffer()) {
     2314        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_legendRenderWindow)->GetBackLeftBuffer()));
     2315    } else {
     2316        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_legendRenderWindow)->GetFrontLeftBuffer()));
     2317    }
     2318    glPixelStorei(GL_PACK_ALIGNMENT, 1);
     2319    if (bytesPerPixel == 4) {
     2320        glReadPixels(0, 0, width, height, GL_BGRA,
     2321                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
     2322    } else {
     2323        glReadPixels(0, 0, width, height, GL_BGR,
     2324                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
     2325    }
     2326    if (glGetError() != GL_NO_ERROR) {
     2327        ERROR("glReadPixels");
     2328    }
     2329#else
     2330    _legendRenderWindow->GetPixelData(0, 0, width-1, height-1,
     2331                                      !_legendRenderWindow->GetDoubleBuffer(),
     2332                                      imgData);
     2333#endif
     2334    TRACE("Leave");
     2335    return true;
     2336}
     2337
    21802338/**
    21812339 * \brief Set camera FOV based on render window height
     
    22652423    setGraphicsObjectAspect<Glyphs>(aspectRatio);
    22662424    setGraphicsObjectAspect<HeightMap>(aspectRatio);
     2425    setGraphicsObjectAspect<Image>(aspectRatio);
    22672426    setGraphicsObjectAspect<LIC>(aspectRatio);
    22682427    setGraphicsObjectAspect<Line>(aspectRatio);
     
    22742433    setGraphicsObjectAspect<Sphere>(aspectRatio);
    22752434    setGraphicsObjectAspect<Streamlines>(aspectRatio);
     2435    setGraphicsObjectAspect<Text3D>(aspectRatio);
    22762436    setGraphicsObjectAspect<Volume>(aspectRatio);
    22772437    setGraphicsObjectAspect<Warp>(aspectRatio);
     
    31843344    mergeGraphicsObjectBounds<Group>(bounds, onlyVisible);
    31853345    mergeGraphicsObjectBounds<HeightMap>(bounds, onlyVisible);
     3346    mergeGraphicsObjectBounds<Image>(bounds, onlyVisible);
    31863347    mergeGraphicsObjectBounds<LIC>(bounds, onlyVisible);
    31873348    mergeGraphicsObjectBounds<Line>(bounds, onlyVisible);
     
    31933354    mergeGraphicsObjectBounds<Sphere>(bounds, onlyVisible);
    31943355    mergeGraphicsObjectBounds<Streamlines>(bounds, onlyVisible);
     3356    mergeGraphicsObjectBounds<Text3D>(bounds, onlyVisible);
    31953357    mergeGraphicsObjectBounds<Volume>(bounds, onlyVisible);
    31963358    mergeGraphicsObjectBounds<Warp>(bounds, onlyVisible);
     
    32533415    mergeGraphicsObjectUnscaledBounds<Glyphs>(bounds, onlyVisible);
    32543416    mergeGraphicsObjectUnscaledBounds<HeightMap>(bounds, onlyVisible);
     3417    mergeGraphicsObjectUnscaledBounds<Image>(bounds, onlyVisible);
    32553418    mergeGraphicsObjectUnscaledBounds<LIC>(bounds, onlyVisible);
    32563419    mergeGraphicsObjectUnscaledBounds<Line>(bounds, onlyVisible);
     
    32623425    mergeGraphicsObjectUnscaledBounds<Sphere>(bounds, onlyVisible);
    32633426    mergeGraphicsObjectUnscaledBounds<Streamlines>(bounds, onlyVisible);
     3427    mergeGraphicsObjectUnscaledBounds<Text3D>(bounds, onlyVisible);
    32643428    mergeGraphicsObjectUnscaledBounds<Volume>(bounds, onlyVisible);
    32653429    mergeGraphicsObjectUnscaledBounds<Warp>(bounds, onlyVisible);
     
    33083472    updateGraphicsObjectFieldRanges<Glyphs>();
    33093473    updateGraphicsObjectFieldRanges<HeightMap>();
     3474    updateGraphicsObjectFieldRanges<Image>();
    33103475    updateGraphicsObjectFieldRanges<LIC>();
    33113476    updateGraphicsObjectFieldRanges<Molecule>();
     3477    updateGraphicsObjectFieldRanges<PolyData>();
    33123478    updateGraphicsObjectFieldRanges<PseudoColor>();
    33133479    updateGraphicsObjectFieldRanges<Streamlines>();
     
    33683534    }
    33693535    _scalarCellDataRange.clear();
     3536    for (FieldRangeHashmap::iterator itr = _scalarFieldDataRange.begin();
     3537         itr != _scalarFieldDataRange.end(); ++itr) {
     3538        delete [] itr->second;
     3539    }
     3540    _scalarFieldDataRange.clear();
    33703541    for (FieldRangeHashmap::iterator itr = _vectorPointDataRange.begin();
    33713542         itr != _vectorPointDataRange.end(); ++itr) {
     
    33923563        _vectorCompCellDataRange[i].clear();
    33933564    }
     3565    for (FieldRangeHashmap::iterator itr = _vectorFieldDataRange.begin();
     3566         itr != _vectorFieldDataRange.end(); ++itr) {
     3567        delete [] itr->second;
     3568    }
     3569    _vectorFieldDataRange.clear();
     3570    for (int i = 0; i < 3; i++) {
     3571        for (FieldRangeHashmap::iterator itr = _vectorCompFieldDataRange[i].begin();
     3572             itr != _vectorCompFieldDataRange[i].end(); ++itr) {
     3573            delete [] itr->second;
     3574        }
     3575        _vectorCompFieldDataRange[i].clear();
     3576    }
    33943577}
    33953578
     
    34103593    }
    34113594    _userScalarCellDataRange.clear();
     3595    for (FieldRangeHashmap::iterator itr = _userScalarFieldDataRange.begin();
     3596         itr != _userScalarFieldDataRange.end(); ++itr) {
     3597        delete [] itr->second;
     3598    }
     3599    _userScalarFieldDataRange.clear();
    34123600    for (FieldRangeHashmap::iterator itr = _userVectorPointDataRange.begin();
    34133601         itr != _userVectorPointDataRange.end(); ++itr) {
     
    34333621        }
    34343622        _userVectorCompCellDataRange[i].clear();
     3623    }
     3624    for (FieldRangeHashmap::iterator itr = _userVectorFieldDataRange.begin();
     3625         itr != _userVectorFieldDataRange.end(); ++itr) {
     3626        delete [] itr->second;
     3627    }
     3628    _userVectorFieldDataRange.clear();
     3629    for (int i = 0; i < 3; i++) {
     3630        for (FieldRangeHashmap::iterator itr = _userVectorCompFieldDataRange[i].begin();
     3631             itr != _userVectorCompFieldDataRange[i].end(); ++itr) {
     3632            delete [] itr->second;
     3633        }
     3634        _userVectorCompFieldDataRange[i].clear();
    34353635    }
    34363636}
     
    34723672                _scalarCellDataRange[*itr][0] = 0;
    34733673                _scalarCellDataRange[*itr][1] = 1;
     3674            }
     3675        }
     3676        names.clear();
     3677        ds->getFieldNames(names, DataSet::FIELD_DATA, 1);
     3678        for (std::vector<std::string>::iterator itr = names.begin();
     3679             itr != names.end(); ++itr) {
     3680            FieldRangeHashmap::iterator fritr =
     3681                _scalarFieldDataRange.find(*itr);
     3682            if (fritr == _scalarFieldDataRange.end()) {
     3683                _scalarFieldDataRange[*itr] = new double[2];
     3684                _scalarFieldDataRange[*itr][0] = 0;
     3685                _scalarFieldDataRange[*itr][1] = 1;
    34743686            }
    34753687        }
     
    35113723                    _vectorCompCellDataRange[i][*itr][0] = 0;
    35123724                    _vectorCompCellDataRange[i][*itr][1] = 1;
     3725                }
     3726            }
     3727        }
     3728        names.clear();
     3729        ds->getFieldNames(names, DataSet::FIELD_DATA, 3);
     3730        for (std::vector<std::string>::iterator itr = names.begin();
     3731             itr != names.end(); ++itr) {
     3732            FieldRangeHashmap::iterator fritr =
     3733                _vectorFieldDataRange.find(*itr);
     3734            if (fritr == _vectorFieldDataRange.end()) {
     3735                _vectorFieldDataRange[*itr] = new double[2];
     3736                _vectorFieldDataRange[*itr][0] = 0;
     3737                _vectorFieldDataRange[*itr][1] = 1;
     3738            }
     3739            for (int i = 0; i < 3; i++) {
     3740                fritr = _vectorCompFieldDataRange[i].find(*itr);
     3741                if (fritr == _vectorCompFieldDataRange[i].end()) {
     3742                    _vectorCompFieldDataRange[i][*itr] = new double[2];
     3743                    _vectorCompFieldDataRange[i][*itr][0] = 0;
     3744                    _vectorCompFieldDataRange[i][*itr][1] = 1;
    35133745                }
    35143746            }
     
    36103842    }
    36113843        break;
     3844    case DataSet::FIELD_DATA: {
     3845        FieldRangeHashmap::iterator itr;
     3846        if (numComponents == 1) {
     3847            itr = _userScalarFieldDataRange.find(name);
     3848            if (itr == _userScalarFieldDataRange.end()) {
     3849                _userScalarFieldDataRange[name] = new double[2];
     3850                memcpy(_userScalarFieldDataRange[name], range, sizeof(double)*2);
     3851            } else {
     3852                found = true;
     3853                memcpy(itr->second, range, sizeof(double)*2);
     3854            }
     3855        } else if (numComponents == 3) {
     3856            if (component == -1) {
     3857                itr = _userVectorFieldDataRange.find(name);
     3858                if (itr == _userVectorFieldDataRange.end()) {
     3859                    _userVectorFieldDataRange[name] = new double[2];
     3860                    memcpy(_userVectorFieldDataRange[name], range, sizeof(double)*2);
     3861                } else {
     3862                    found = true;
     3863                    memcpy(itr->second, range, sizeof(double)*2);
     3864                }
     3865            } else if (component >= 0 && component <= 3) {
     3866                itr = _userVectorCompFieldDataRange[component].find(name);
     3867                if (itr == _userVectorCompFieldDataRange[component].end()) {
     3868                    _userVectorCompFieldDataRange[component][name] = new double[2];
     3869                    memcpy(_userVectorCompFieldDataRange[component][name], range, sizeof(double)*2);
     3870                } else {
     3871                    found = true;
     3872                    memcpy(itr->second, range, sizeof(double)*2);
     3873                }
     3874            }
     3875        }
     3876    }
     3877        break;
    36123878    default:
    36133879        ERROR("Bad Field Type");
     
    36263892/**
    36273893 * \brief Get the cumulative range across all DataSets for a point
    3628  * data field if it exists, otherwise a cell data field if it exists
     3894 * data field if it exists, otherwise a cell data field if it exists,
     3895 * otherwise a field data field if it exists
    36293896 *
    36303897 * \param[out] range Pointer to an array of 2 doubles
     
    36393906{
    36403907    bool ret;
    3641     if (!(ret = getCumulativeDataRange(range, name, DataSet::POINT_DATA,
    3642                                        numComponents, component)))
    3643         ret = getCumulativeDataRange(range, name, DataSet::CELL_DATA,
     3908    if ((ret = getCumulativeDataRange(range, name, DataSet::POINT_DATA,
     3909                                      numComponents, component))) {
     3910        ; // Found point data
     3911    } else if ((ret = getCumulativeDataRange(range, name, DataSet::CELL_DATA,
     3912                                             numComponents, component))) {
     3913        ; // Found cell data
     3914       
     3915    } else {
     3916        ret = getCumulativeDataRange(range, name, DataSet::FIELD_DATA,
    36443917                                     numComponents, component);
     3918    }
    36453919    return ret;
    36463920}
     
    37394013    }
    37404014        break;
     4015    case DataSet::FIELD_DATA: {
     4016        FieldRangeHashmap::iterator itr;
     4017        if (numComponents == 1) {
     4018            itr = _userScalarFieldDataRange.find(name);
     4019            if (itr == _userScalarFieldDataRange.end()) {
     4020                itr = _scalarFieldDataRange.find(name);
     4021                if (itr == _scalarFieldDataRange.end()) {
     4022                    return false;
     4023                }
     4024            }
     4025            memcpy(range, itr->second, sizeof(double)*2);
     4026            return true;
     4027        } else if (numComponents == 3) {
     4028            if (component == -1) {
     4029                itr = _userVectorFieldDataRange.find(name);
     4030                if (itr == _userVectorFieldDataRange.end()) {
     4031                    itr = _vectorFieldDataRange.find(name);
     4032                    if (itr == _vectorFieldDataRange.end()) {
     4033                        return false;
     4034                    }
     4035                }
     4036                memcpy(range, itr->second, sizeof(double)*2);
     4037                return true;
     4038            } else if (component >= 0 && component <= 3) {
     4039                itr = _userVectorCompFieldDataRange[component].find(name);
     4040                if (itr == _userVectorCompFieldDataRange[component].end()) {
     4041                    itr = _vectorCompFieldDataRange[component].find(name);
     4042                    if (itr == _vectorCompFieldDataRange[component].end()) {
     4043                        return false;
     4044                    }
     4045                }
     4046                memcpy(range, itr->second, sizeof(double)*2);
     4047                return true;
     4048            }
     4049        }
     4050    }
     4051        break;
    37414052    default:
    37424053        break;
     
    37574068        collectDataRanges(itr->second, itr->first.c_str(),
    37584069                          DataSet::CELL_DATA, -1,
     4070                          _cumulativeRangeOnlyVisible);
     4071    }
     4072    for (FieldRangeHashmap::iterator itr = _scalarFieldDataRange.begin();
     4073         itr != _scalarFieldDataRange.end(); ++itr) {
     4074        collectDataRanges(itr->second, itr->first.c_str(),
     4075                          DataSet::FIELD_DATA, -1,
    37594076                          _cumulativeRangeOnlyVisible);
    37604077    }
     
    37844101            collectDataRanges(itr->second, itr->first.c_str(),
    37854102                              DataSet::CELL_DATA, i,
     4103                              _cumulativeRangeOnlyVisible);
     4104        }
     4105    }
     4106    for (FieldRangeHashmap::iterator itr = _vectorFieldDataRange.begin();
     4107         itr != _vectorFieldDataRange.end(); ++itr) {
     4108        collectDataRanges(itr->second, itr->first.c_str(),
     4109                          DataSet::FIELD_DATA, -1,
     4110                          _cumulativeRangeOnlyVisible);
     4111    }
     4112    for (int i = 0; i < 3; i++) {
     4113        for (FieldRangeHashmap::iterator itr = _vectorCompFieldDataRange[i].begin();
     4114             itr != _vectorCompFieldDataRange[i].end(); ++itr) {
     4115            collectDataRanges(itr->second, itr->first.c_str(),
     4116                              DataSet::FIELD_DATA, i,
    37864117                              _cumulativeRangeOnlyVisible);
    37874118        }
     
    40244355    if (id.compare("all") == 0 || getGraphicsObject<HeightMap>(id) != NULL)
    40254356        setGraphicsObjectOpacity<HeightMap>(id, opacity);
     4357    if (id.compare("all") == 0 || getGraphicsObject<Image>(id) != NULL)
     4358        setGraphicsObjectOpacity<Image>(id, opacity);
    40264359    if (id.compare("all") == 0 || getGraphicsObject<LIC>(id) != NULL)
    40274360        setGraphicsObjectOpacity<LIC>(id, opacity);
     
    40804413    if (id.compare("all") == 0 || getGraphicsObject<HeightMap>(id) != NULL)
    40814414        setGraphicsObjectVisibility<HeightMap>(id, state);
     4415    if (id.compare("all") == 0 || getGraphicsObject<Image>(id) != NULL)
     4416        setGraphicsObjectVisibility<Image>(id, state);
    40824417    if (id.compare("all") == 0 || getGraphicsObject<LIC>(id) != NULL)
    40834418        setGraphicsObjectVisibility<LIC>(id, state);
     
    42294564    setGraphicsObjectClippingPlanes<Group>(_activeClipPlanes);
    42304565    setGraphicsObjectClippingPlanes<HeightMap>(_activeClipPlanes);
     4566    setGraphicsObjectClippingPlanes<Image>(_activeClipPlanes);
    42314567    setGraphicsObjectClippingPlanes<LIC>(_activeClipPlanes);
    42324568    setGraphicsObjectClippingPlanes<Line>(_activeClipPlanes);
     
    42384574    setGraphicsObjectClippingPlanes<Sphere>(_activeClipPlanes);
    42394575    setGraphicsObjectClippingPlanes<Streamlines>(_activeClipPlanes);
     4576    setGraphicsObjectClippingPlanes<Text3D>(_activeClipPlanes);
    42404577    setGraphicsObjectClippingPlanes<Volume>(_activeClipPlanes);
    42414578    setGraphicsObjectClippingPlanes<Warp>(_activeClipPlanes);
  • trunk/packages/vizservers/vtkvis/Renderer.h

    r3771 r3818  
    4040#include "Group.h"
    4141#include "HeightMap.h"
     42#include "Image.h"
    4243#include "LIC.h"
    4344#include "Line.h"
     
    4950#include "Sphere.h"
    5051#include "Streamlines.h"
     52#include "Text3D.h"
    5153#include "Volume.h"
    5254#include "Warp.h"
     
    420422
    421423    void setColorMapNumberOfTableEntries(const ColorMapId& id, int numEntries);
     424
     425    bool renderColorMap(const ColorMapId& id,
     426                        int width, int height,
     427                        bool opaque,
     428                        vtkUnsignedCharArray *imgData);
    422429
    423430    bool renderColorMap(const ColorMapId& id,
     
    745752                               const char *name, double range[2] = NULL);
    746753
     754    // Images
     755
     756    void setImageBackground(const DataSetId& id, bool state);
     757
     758    void setImageBacking(const DataSetId& id, bool state);
     759
     760    void setImageBorder(const DataSetId& id, bool state);
     761
     762    void setImageExtents(const DataSetId& id, int extents[6]);
     763
     764    void setImageLevel(const DataSetId& id, double level);
     765
     766    void setImageWindow(const DataSetId& id, double window);
     767
     768    void setImageZSlice(const DataSetId& id, int z);
    747769
    748770    // Lines
     
    796818                               PolyData::CloudStyle style);
    797819
     820    void setPolyDataColorMode(const DataSetId& id,
     821                              PolyData::ColorMode mode,
     822                              const char *name, double range[2] = NULL);
     823
     824    void setPolyDataColorMode(const DataSetId& id,
     825                              PolyData::ColorMode mode,
     826                              DataSet::DataAttributeType type,
     827                              const char *name, double range[2] = NULL);
     828
    798829    // Color-mapped surfaces
    799830
     
    880911
    881912    void setStreamlinesTypeToRibbons(const DataSetId& id, double width, double angle);
     913
     914    // Text3Ds
     915
     916    bool addText3D(const DataSetId& id, const char *string,
     917                   const char *fontFamily, int fontSize,
     918                   bool bold = false, bool italic = false, bool shadow = false);
     919
     920    void setText3DBold(const DataSetId& id, bool state);
     921
     922    void setText3DFollowCamera(const DataSetId& id, bool state);
     923
     924    void setText3DFont(const DataSetId& id, const char *fontFamily);
     925
     926    void setText3DFontSize(const DataSetId& id, int size);
     927
     928    void setText3DItalic(const DataSetId& id, bool state);
     929
     930    void setText3DShadow(const DataSetId& id, bool state);
     931
     932    void setText3DText(const DataSetId& id, const char *text);
    882933
    883934    // Volumes
     
    919970    typedef std::tr1::unordered_map<DataSetId, Group *> GroupHashmap;
    920971    typedef std::tr1::unordered_map<DataSetId, HeightMap *> HeightMapHashmap;
     972    typedef std::tr1::unordered_map<DataSetId, Image *> ImageHashmap;
    921973    typedef std::tr1::unordered_map<DataSetId, LIC *> LICHashmap;
    922974    typedef std::tr1::unordered_map<DataSetId, Line *> LineHashmap;
     
    928980    typedef std::tr1::unordered_map<DataSetId, Sphere *> SphereHashmap;
    929981    typedef std::tr1::unordered_map<DataSetId, Streamlines *> StreamlinesHashmap;
     982    typedef std::tr1::unordered_map<DataSetId, Text3D *> Text3DHashmap;
    930983    typedef std::tr1::unordered_map<DataSetId, Volume *> VolumeHashmap;
    931984    typedef std::tr1::unordered_map<DataSetId, Warp *> WarpHashmap;
     
    10231076    FieldRangeHashmap _vectorCellDataRange;
    10241077    FieldRangeHashmap _vectorCompCellDataRange[3];
     1078    FieldRangeHashmap _scalarFieldDataRange;
     1079    FieldRangeHashmap _vectorFieldDataRange;
     1080    FieldRangeHashmap _vectorCompFieldDataRange[3];
    10251081
    10261082    FieldRangeHashmap _userScalarPointDataRange;
     
    10301086    FieldRangeHashmap _userVectorCellDataRange;
    10311087    FieldRangeHashmap _userVectorCompCellDataRange[3];
     1088    FieldRangeHashmap _userScalarFieldDataRange;
     1089    FieldRangeHashmap _userVectorFieldDataRange;
     1090    FieldRangeHashmap _userVectorCompFieldDataRange[3];
    10321091
    10331092    bool _axesAutoBounds[3];
     
    10501109    GroupHashmap _groups;
    10511110    HeightMapHashmap _heightMaps;
     1111    ImageHashmap _images;
    10521112    LICHashmap _lics;
    10531113    LineHashmap _lines;
     
    10591119    SphereHashmap _spheres;
    10601120    StreamlinesHashmap _streamlines;
     1121    Text3DHashmap _text3Ds;
    10611122    VolumeHashmap _volumes;
    10621123    WarpHashmap _warps;
  • trunk/packages/vizservers/vtkvis/RendererCmd.cpp

    r3798 r3818  
    30263026    Contour2D::ColorMode mode;
    30273027    const char *str = Tcl_GetString(objv[2]);
    3028     if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     3028    if (str[0] == 'c' &&
     3029        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    30293030        mode = Contour2D::COLOR_CONSTANT;
    30303031    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    30403041    } else {
    30413042        Tcl_AppendResult(interp, "bad color mode option \"", str,
    3042                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     3043                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    30433044        return TCL_ERROR;
    30443045    }
     
    32533254    {"add",          1, Contour2DAddOp, 4, 5, "oper value ?dataSetName?"},
    32543255    {"ccolor",       2, Contour2DLineColorOp, 5, 6, "r g b ?dataSetName?"},
     3256    {"color",        5, Contour2DLineColorOp, 5, 6, "r g b ?dataSetName?"},
    32553257    {"colormap",     7, Contour2DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    32563258    {"colormode",    7, Contour2DColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    34013403    Contour3D::ColorMode mode;
    34023404    const char *str = Tcl_GetString(objv[2]);
    3403     if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     3405    if (str[0] == 'c' &&
     3406        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    34043407        mode = Contour3D::COLOR_CONSTANT;
    34053408    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    34153418    } else {
    34163419        Tcl_AppendResult(interp, "bad color mode option \"", str,
    3417                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     3420                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    34183421        return TCL_ERROR;
    34193422    }
     
    36883691    {"add",          1, Contour3DAddOp, 4, 5, "oper value ?dataSetName?"},
    36893692    {"ccolor",       2, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
     3693    {"color",        5, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
    36903694    {"colormap",     7, Contour3DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    36913695    {"colormode",    7, Contour3DColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    41224126    {"ccolor",       2, CutplaneColorOp, 5, 6, "r g b ?dataSetName?"},
    41234127    {"cloudstyle",   2, CutplaneCloudStyleOp, 3, 4, "style ?dataSetName?"},
     4128    {"color",        5, CutplaneColorOp, 5, 6, "r g b ?dataSetName?"},
    41244129    {"colormap",     7, CutplaneColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    41254130    {"colormode",    7, CutplaneColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    54465451    Glyphs::ColorMode mode;
    54475452    const char *str = Tcl_GetString(objv[2]);
    5448     if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     5453    if (str[0] == 'c' &&
     5454        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    54495455        mode = Glyphs::COLOR_CONSTANT;
    54505456    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    54605466    } else {
    54615467        Tcl_AppendResult(interp, "bad color mode option \"", str,
    5462                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     5468                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    54635469        return TCL_ERROR;
    54645470    }
     
    58615867    {"add",          1, GlyphsAddOp, 3, 4, "shape ?dataSetName?"},
    58625868    {"ccolor",       2, GlyphsColorOp, 5, 6, "r g b ?dataSetName?"},
     5869    {"color",        5, GlyphsColorOp, 5, 6, "r g b ?dataSetName?"},
    58635870    {"colormap",     7, GlyphsColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    58645871    {"colormode",    7, GlyphsColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    62446251    HeightMap::ColorMode mode;
    62456252    const char *str = Tcl_GetString(objv[2]);
    6246     if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     6253    if (str[0] == 'c' &&
     6254        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    62476255        mode = HeightMap::COLOR_CONSTANT;
    62486256    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    62586266    } else {
    62596267        Tcl_AppendResult(interp, "bad color mode option \"", str,
    6260                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     6268                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    62616269        return TCL_ERROR;
    62626270    }
     
    62706278    } else {
    62716279        g_renderer->setHeightMapColorMode("all", mode, fieldName);
     6280    }
     6281    return TCL_OK;
     6282}
     6283
     6284static int
     6285HeightMapColorMode2Op(ClientData clientData, Tcl_Interp *interp, int objc,
     6286                      Tcl_Obj *const *objv)
     6287{
     6288    HeightMap::ColorMode mode;
     6289    const char *str = Tcl_GetString(objv[2]);
     6290    if (str[0] == 'c' &&
     6291        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
     6292        mode = HeightMap::COLOR_CONSTANT;
     6293    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     6294        mode = HeightMap::COLOR_BY_SCALAR;
     6295    } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
     6296        mode = HeightMap::COLOR_BY_VECTOR_MAGNITUDE;
     6297    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
     6298        mode = HeightMap::COLOR_BY_VECTOR_X;
     6299    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
     6300        mode = HeightMap::COLOR_BY_VECTOR_Y;
     6301    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
     6302        mode = HeightMap::COLOR_BY_VECTOR_Z;
     6303    } else {
     6304        Tcl_AppendResult(interp, "bad color mode option \"", str,
     6305                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     6306        return TCL_ERROR;
     6307    }
     6308    const char *fieldName = Tcl_GetString(objv[3]);
     6309    if (mode == HeightMap::COLOR_CONSTANT) {
     6310        fieldName = NULL;
     6311    }
     6312    str = Tcl_GetString(objv[4]);
     6313    DataSet::DataAttributeType association = DataSet::POINT_DATA;
     6314    bool haveAssoc = false;
     6315    if (str[0] == 'p' && strcmp(str, "point_data") == 0) {
     6316        association = DataSet::POINT_DATA;
     6317        haveAssoc = true;
     6318    } else if (str[0] == 'c' && strcmp(str, "cell_data") == 0) {
     6319        association = DataSet::CELL_DATA;
     6320        haveAssoc = true;
     6321    } else if (str[0] == 'f' && strcmp(str, "field_data") == 0) {
     6322        association = DataSet::FIELD_DATA;
     6323        haveAssoc = true;
     6324    } else if (str[0] == 'a' && strcmp(str, "any") == 0) {
     6325        haveAssoc = false;
     6326    } else {
     6327        Tcl_AppendResult(interp, "bad color mode association option \"", str,
     6328                         "\": should be one of: 'point_data', 'cell_data', 'field_data', 'any'", (char*)NULL);
     6329        return TCL_ERROR;
     6330    }
     6331    double *range = NULL;
     6332    if (objc >= 7) {
     6333        range = new double[2];
     6334        if (Tcl_GetDoubleFromObj(interp, objv[5], &range[0]) != TCL_OK ||
     6335            Tcl_GetDoubleFromObj(interp, objv[6], &range[1]) != TCL_OK) {
     6336            return TCL_ERROR;
     6337        }
     6338    }
     6339    if (objc == 6 || objc == 8) {
     6340        const char *name = Tcl_GetString((objc == 6 ? objv[5] : objv[7]));
     6341        if (haveAssoc) {
     6342            g_renderer->setHeightMapColorMode(name, mode, association, fieldName, range);
     6343        } else {
     6344            g_renderer->setHeightMapColorMode(name, mode, fieldName, range);
     6345        }
     6346    } else {
     6347        if (haveAssoc) {
     6348            g_renderer->setHeightMapColorMode("all", mode, association, fieldName, range);
     6349        } else {
     6350            g_renderer->setHeightMapColorMode("all", mode, fieldName, range);
     6351        }
     6352    }
     6353    if (range != NULL) {
     6354        delete [] range;
    62726355    }
    62736356    return TCL_OK;
     
    66716754    {"ccolor",       2, HeightMapColorOp, 5, 6, "r g b ?dataSetName?"},
    66726755    {"cloudstyle",   2, HeightMapCloudStyleOp, 3, 4, "style ?dataSetName?"},
     6756    {"color",        5, HeightMapColorOp, 5, 6, "r g b ?dataSetName?"},
    66736757    {"colormap",     7, HeightMapColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    6674     {"colormode",    7, HeightMapColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     6758    {"colormode",    9, HeightMapColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     6759    {"colormode2",   10,HeightMapColorMode2Op, 5, 8, "mode fieldName association ?min max? ?dataSetName?"},
    66756760    {"contourlist",  3, HeightMapContourListOp, 3, 4, "contourList ?dataSetName?"},
    66766761    {"delete",       1, HeightMapDeleteOp, 2, 3, "?dataSetName?"},
     
    67126797
    67136798static int
     6799ImageAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6800           Tcl_Obj *const *objv)
     6801{
     6802    if (objc == 3) {
     6803        const char *name = Tcl_GetString(objv[2]);
     6804        if (!g_renderer->addGraphicsObject<Image>(name)) {
     6805            Tcl_AppendResult(interp, "Failed to create image", (char*)NULL);
     6806            return TCL_ERROR;
     6807        }
     6808    } else {
     6809        if (!g_renderer->addGraphicsObject<Image>("all")) {
     6810            Tcl_AppendResult(interp, "Failed to create iamge for one or more data sets", (char*)NULL);
     6811            return TCL_ERROR;
     6812        }
     6813    }
     6814    return TCL_OK;
     6815}
     6816
     6817static int
     6818ImageBackgroundOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6819                  Tcl_Obj *const *objv)
     6820{
     6821    bool state;
     6822    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     6823        return TCL_ERROR;
     6824    }
     6825    if (objc == 4) {
     6826        const char *name = Tcl_GetString(objv[3]);
     6827        g_renderer->setImageBackground(name, state);
     6828    } else {
     6829        g_renderer->setImageBackground("all", state);
     6830    }
     6831    return TCL_OK;
     6832}
     6833
     6834static int
     6835ImageBackingOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6836               Tcl_Obj *const *objv)
     6837{
     6838    bool state;
     6839    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     6840        return TCL_ERROR;
     6841    }
     6842    if (objc == 4) {
     6843        const char *name = Tcl_GetString(objv[3]);
     6844        g_renderer->setImageBacking(name, state);
     6845    } else {
     6846        g_renderer->setImageBacking("all", state);
     6847    }
     6848    return TCL_OK;
     6849}
     6850
     6851static int
     6852ImageBorderOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6853              Tcl_Obj *const *objv)
     6854{
     6855    bool state;
     6856    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     6857        return TCL_ERROR;
     6858    }
     6859    if (objc == 4) {
     6860        const char *name = Tcl_GetString(objv[3]);
     6861        g_renderer->setImageBorder(name, state);
     6862    } else {
     6863        g_renderer->setImageBorder("all", state);
     6864    }
     6865    return TCL_OK;
     6866}
     6867
     6868static int
     6869ImageColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6870             Tcl_Obj *const *objv)
     6871{
     6872    float color[3];
     6873    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
     6874        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
     6875        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
     6876        return TCL_ERROR;
     6877    }
     6878    if (objc == 6) {
     6879        const char *name = Tcl_GetString(objv[5]);
     6880        g_renderer->setGraphicsObjectColor<Image>(name, color);
     6881    } else {
     6882        g_renderer->setGraphicsObjectColor<Image>("all", color);
     6883    }
     6884    return TCL_OK;
     6885}
     6886
     6887static int
     6888ImageColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6889                Tcl_Obj *const *objv)
     6890{
     6891    const char *colorMapName = Tcl_GetString(objv[2]);
     6892    if (objc == 4) {
     6893        const char *dataSetName = Tcl_GetString(objv[3]);
     6894        g_renderer->setGraphicsObjectColorMap<Image>(dataSetName, colorMapName);
     6895    } else {
     6896        g_renderer->setGraphicsObjectColorMap<Image>("all", colorMapName);
     6897    }
     6898    return TCL_OK;
     6899}
     6900
     6901static int
     6902ImageDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6903              Tcl_Obj *const *objv)
     6904{
     6905    if (objc == 3) {
     6906        const char *name = Tcl_GetString(objv[2]);
     6907        g_renderer->deleteGraphicsObject<Image>(name);
     6908    } else {
     6909        g_renderer->deleteGraphicsObject<Image>("all");
     6910    }
     6911    return TCL_OK;
     6912}
     6913
     6914static int
     6915ImageExtentsOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6916               Tcl_Obj *const *objv)
     6917{
     6918    int extents[6];
     6919    if (Tcl_GetIntFromObj(interp, objv[2], &extents[0]) != TCL_OK ||
     6920        Tcl_GetIntFromObj(interp, objv[3], &extents[1]) != TCL_OK ||
     6921        Tcl_GetIntFromObj(interp, objv[4], &extents[2]) != TCL_OK ||
     6922        Tcl_GetIntFromObj(interp, objv[5], &extents[3]) != TCL_OK ||
     6923        Tcl_GetIntFromObj(interp, objv[6], &extents[4]) != TCL_OK ||
     6924        Tcl_GetIntFromObj(interp, objv[7], &extents[5]) != TCL_OK) {
     6925        return TCL_ERROR;
     6926    }
     6927    if (objc == 9) {
     6928        const char *name = Tcl_GetString(objv[8]);
     6929        g_renderer->setImageExtents(name, extents);
     6930    } else {
     6931        g_renderer->setImageExtents("all", extents);
     6932    }
     6933    return TCL_OK;
     6934}
     6935
     6936static int
     6937ImageLevelOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6938             Tcl_Obj *const *objv)
     6939{
     6940    double level;
     6941    if (Tcl_GetDoubleFromObj(interp, objv[2], &level) != TCL_OK) {
     6942        return TCL_ERROR;
     6943    }
     6944    if (objc == 4) {
     6945        const char *name = Tcl_GetString(objv[3]);
     6946        g_renderer->setImageLevel(name, level);
     6947    } else {
     6948        g_renderer->setImageLevel("all", level);
     6949    }
     6950    return TCL_OK;
     6951}
     6952
     6953static int
     6954ImageOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6955               Tcl_Obj *const *objv)
     6956{
     6957    double opacity;
     6958    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
     6959        return TCL_ERROR;
     6960    }
     6961    if (objc == 4) {
     6962        const char *name = Tcl_GetString(objv[3]);
     6963        g_renderer->setGraphicsObjectOpacity<Image>(name, opacity);
     6964    } else {
     6965        g_renderer->setGraphicsObjectOpacity<Image>("all", opacity);
     6966    }
     6967    return TCL_OK;
     6968}
     6969
     6970static int
     6971ImageOrientOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6972              Tcl_Obj *const *objv)
     6973{
     6974    double quat[4];
     6975    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
     6976        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
     6977        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
     6978        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
     6979        return TCL_ERROR;
     6980    }
     6981    if (objc == 7) {
     6982        const char *name = Tcl_GetString(objv[6]);
     6983        g_renderer->setGraphicsObjectOrientation<Image>(name, quat);
     6984    } else {
     6985        g_renderer->setGraphicsObjectOrientation<Image>("all", quat);
     6986    }
     6987    return TCL_OK;
     6988}
     6989
     6990static int
     6991ImagePositionOp(ClientData clientData, Tcl_Interp *interp, int objc,
     6992                Tcl_Obj *const *objv)
     6993{
     6994    double pos[3];
     6995    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
     6996        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
     6997        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
     6998        return TCL_ERROR;
     6999    }
     7000    if (objc == 6) {
     7001        const char *name = Tcl_GetString(objv[5]);
     7002        g_renderer->setGraphicsObjectPosition<Image>(name, pos);
     7003    } else {
     7004        g_renderer->setGraphicsObjectPosition<Image>("all", pos);
     7005    }
     7006    return TCL_OK;
     7007}
     7008
     7009static int
     7010ImageScaleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     7011             Tcl_Obj *const *objv)
     7012{
     7013    double scale[3];
     7014    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
     7015        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
     7016        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
     7017        return TCL_ERROR;
     7018    }
     7019    if (objc == 6) {
     7020        const char *name = Tcl_GetString(objv[5]);
     7021        g_renderer->setGraphicsObjectScale<Image>(name, scale);
     7022    } else {
     7023        g_renderer->setGraphicsObjectScale<Image>("all", scale);
     7024    }
     7025    return TCL_OK;
     7026}
     7027
     7028static int
     7029ImageVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     7030               Tcl_Obj *const *objv)
     7031{
     7032    bool state;
     7033    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     7034        return TCL_ERROR;
     7035    }
     7036    if (objc == 4) {
     7037        const char *name = Tcl_GetString(objv[3]);
     7038        g_renderer->setGraphicsObjectVisibility<Image>(name, state);
     7039    } else {
     7040        g_renderer->setGraphicsObjectVisibility<Image>("all", state);
     7041    }
     7042    return TCL_OK;
     7043}
     7044
     7045static int
     7046ImageWindowOp(ClientData clientData, Tcl_Interp *interp, int objc,
     7047              Tcl_Obj *const *objv)
     7048{
     7049    double window;
     7050    if (Tcl_GetDoubleFromObj(interp, objv[2], &window) != TCL_OK) {
     7051        return TCL_ERROR;
     7052    }
     7053    if (objc == 4) {
     7054        const char *name = Tcl_GetString(objv[3]);
     7055        g_renderer->setImageLevel(name, window);
     7056    } else {
     7057        g_renderer->setImageLevel("all", window);
     7058    }
     7059    return TCL_OK;
     7060}
     7061
     7062static int
     7063ImageZSliceOp(ClientData clientData, Tcl_Interp *interp, int objc,
     7064              Tcl_Obj *const *objv)
     7065{
     7066    int slice;
     7067    if (Tcl_GetIntFromObj(interp, objv[2], &slice) != TCL_OK) {
     7068        return TCL_ERROR;
     7069    }
     7070    if (objc == 4) {
     7071        const char *name = Tcl_GetString(objv[3]);
     7072        g_renderer->setImageZSlice(name, slice);
     7073    } else {
     7074        g_renderer->setImageZSlice("all", slice);
     7075    }
     7076    return TCL_OK;
     7077}
     7078
     7079static Rappture::CmdSpec imageOps[] = {
     7080    {"add",          1, ImageAddOp, 2, 3, "?dataSetName?"},
     7081    {"backing",      2, ImageBackingOp, 3, 4, "bool ?dataSetName?"},
     7082    {"bg",           2, ImageBackgroundOp, 3, 4, "bool ?dataSetName?"},
     7083    {"border",       2, ImageBorderOp, 3, 4, "bool ?dataSetName?"},
     7084    {"color",        5, ImageColorOp, 5, 6, "r g b ?dataSetName?"},
     7085    {"colormap",     6, ImageColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     7086    {"delete",       1, ImageDeleteOp, 2, 3, "?dataSetName?"},
     7087    {"extents",      1, ImageExtentsOp, 8, 9, "xmin xmax ymin ymax zmin zmax ?dataSetName?"},
     7088    {"level",        1, ImageLevelOp, 3, 4, "val ?dataSetName?"},
     7089    {"opacity",      2, ImageOpacityOp, 3, 4, "value ?dataSetName?"},
     7090    {"orient",       2, ImageOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
     7091    {"pos",          1, ImagePositionOp, 5, 6, "x y z ?dataSetName?"},
     7092    {"scale",        1, ImageScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     7093    {"visible",      1, ImageVisibleOp, 3, 4, "bool ?dataSetName?"},
     7094    {"window",       1, ImageWindowOp, 3, 4, "val ?dataSetName?"},
     7095    {"zslice",       1, ImageZSliceOp, 3, 4, "val ?dataSetName?"}
     7096};
     7097static int nImageOps = NumCmdSpecs(imageOps);
     7098
     7099static int
     7100ImageCmd(ClientData clientData, Tcl_Interp *interp, int objc,
     7101         Tcl_Obj *const *objv)
     7102{
     7103    Tcl_ObjCmdProc *proc;
     7104
     7105    proc = Rappture::GetOpFromObj(interp, nImageOps, imageOps,
     7106                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
     7107    if (proc == NULL) {
     7108        return TCL_ERROR;
     7109    }
     7110    return (*proc) (clientData, interp, objc, objv);
     7111}
     7112
     7113static int
    67147114ImageFlushCmd(ClientData clientData, Tcl_Interp *interp, int objc,
    67157115              Tcl_Obj *const *objv)
     
    68187218
    68197219static int
     7220LegendSimpleCmd(ClientData clientData, Tcl_Interp *interp, int objc,
     7221                Tcl_Obj *const *objv)
     7222{
     7223    if (objc != 4) {
     7224        Tcl_AppendResult(interp, "wrong # args: should be \"",
     7225                Tcl_GetString(objv[0]), " colormapName width height\"", (char*)NULL);
     7226        return TCL_ERROR;
     7227    }
     7228    const char *colorMapName = Tcl_GetString(objv[1]);
     7229
     7230    int width, height;
     7231    if (Tcl_GetIntFromObj(interp, objv[2], &width) != TCL_OK ||
     7232        Tcl_GetIntFromObj(interp, objv[3], &height) != TCL_OK) {
     7233        return TCL_ERROR;
     7234    }
     7235
     7236    vtkSmartPointer<vtkUnsignedCharArray> imgData =
     7237        vtkSmartPointer<vtkUnsignedCharArray>::New();
     7238
     7239    if (!g_renderer->renderColorMap(colorMapName, width, height, true, imgData)) {
     7240        Tcl_AppendResult(interp, "Color map \"",
     7241                         colorMapName, "\" was not found", (char*)NULL);
     7242        return TCL_ERROR;
     7243    }
     7244
     7245#ifdef DEBUG
     7246# ifdef RENDER_TARGA
     7247    writeTGAFile("/tmp/legend.tga", imgData->GetPointer(0), width, height,
     7248                 TARGA_BYTES_PER_PIXEL);
     7249# else
     7250    writeTGAFile("/tmp/legend.tga", imgData->GetPointer(0), width, height,
     7251                 TARGA_BYTES_PER_PIXEL, true);
     7252# endif
     7253#else
     7254    char cmd[256];
     7255    snprintf(cmd, sizeof(cmd), "nv>legend {%s} {} 0 1", colorMapName);
     7256
     7257# ifdef USE_THREADS
     7258#  ifdef RENDER_TARGA
     7259    ResponseQueue *queue = (ResponseQueue *)clientData;
     7260    queueTGA(queue, cmd, imgData->GetPointer(0), width, height,
     7261             TARGA_BYTES_PER_PIXEL);
     7262#  else
     7263    ResponseQueue *queue = (ResponseQueue *)clientData;
     7264    queuePPM(queue, cmd, imgData->GetPointer(0), width, height);
     7265#  endif
     7266# else
     7267#  ifdef RENDER_TARGA
     7268    writeTGA(g_fdOut, cmd, imgData->GetPointer(0), width, height,
     7269             TARGA_BYTES_PER_PIXEL);
     7270#  else
     7271    writePPM(g_fdOut, cmd, imgData->GetPointer(0), width, height);
     7272#  endif
     7273# endif // USE_THREADS
     7274#endif // DEBUG
     7275    return TCL_OK;
     7276}
     7277
     7278static int
    68207279LICAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
    68217280         Tcl_Obj *const *objv)
     
    76118070    if (str[0] == 'b' && strcmp(str, "by_elements") == 0) {
    76128071        mode = Molecule::COLOR_BY_ELEMENTS;
    7613     } else if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     8072    } else if (str[0] == 'c' &&
     8073               (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    76148074        mode = Molecule::COLOR_CONSTANT;
    76158075    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    76258085    } else {
    76268086        Tcl_AppendResult(interp, "bad color mode option \"", str,
    7627                          "\": should be one of: 'by_elements', 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     8087                         "\": should be one of: 'by_elements', 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    76288088        return TCL_ERROR;
    76298089    }
     
    78758335    {"bstyle",       3, MoleculeBondStyleOp, 3, 4, "value ?dataSetName?"},
    78768336    {"ccolor",       2, MoleculeColorOp, 5, 6, "r g b ?dataSetName?"},
     8337    {"color",        5, MoleculeColorOp, 5, 6, "r g b ?dataSetName?"},
    78778338    {"colormap",     7, MoleculeColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    78788339    {"colormode",    7, MoleculeColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    81618622
    81628623static int
     8624PolyDataColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8625                   Tcl_Obj *const *objv)
     8626{
     8627    const char *colorMapName = Tcl_GetString(objv[2]);
     8628    if (objc == 4) {
     8629        const char *dataSetName = Tcl_GetString(objv[3]);
     8630        g_renderer->setGraphicsObjectColorMap<PolyData>(dataSetName, colorMapName);
     8631    } else {
     8632        g_renderer->setGraphicsObjectColorMap<PolyData>("all", colorMapName);
     8633    }
     8634    return TCL_OK;
     8635}
     8636
     8637static int
     8638PolyDataColorModeOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8639                       Tcl_Obj *const *objv)
     8640{
     8641    PolyData::ColorMode mode;
     8642    const char *str = Tcl_GetString(objv[2]);
     8643    if (str[0] == 'c' &&
     8644        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
     8645        mode = PolyData::COLOR_CONSTANT;
     8646    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     8647        mode = PolyData::COLOR_BY_SCALAR;
     8648    } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
     8649        mode = PolyData::COLOR_BY_VECTOR_MAGNITUDE;
     8650    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
     8651        mode = PolyData::COLOR_BY_VECTOR_X;
     8652    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
     8653        mode = PolyData::COLOR_BY_VECTOR_Y;
     8654    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
     8655        mode = PolyData::COLOR_BY_VECTOR_Z;
     8656    } else {
     8657        Tcl_AppendResult(interp, "bad color mode option \"", str,
     8658                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
     8659        return TCL_ERROR;
     8660    }
     8661    const char *fieldName = Tcl_GetString(objv[3]);
     8662    if (mode == PolyData::COLOR_CONSTANT) {
     8663        fieldName = NULL;
     8664    }
     8665    if (objc == 5) {
     8666        const char *name = Tcl_GetString(objv[4]);
     8667        g_renderer->setPolyDataColorMode(name, mode, fieldName);
     8668    } else {
     8669        g_renderer->setPolyDataColorMode("all", mode, fieldName);
     8670    }
     8671    return TCL_OK;
     8672}
     8673
     8674static int
    81638675PolyDataCullingOp(ClientData clientData, Tcl_Interp *interp, int objc,
    81648676                  Tcl_Obj *const *objv)
     
    84568968static Rappture::CmdSpec polyDataOps[] = {
    84578969    {"add",       1, PolyDataAddOp, 2, 3, "?dataSetName?"},
     8970    {"ccolor",    2, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
    84588971    {"cloudstyle",2, PolyDataCloudStyleOp, 3, 4, "style ?dataSetName?"},
    8459     {"color",     2, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
     8972    {"color",     5, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
     8973    {"colormap",  7, PolyDataColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     8974    {"colormode", 7, PolyDataColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
    84608975    {"culling",   2, PolyDataCullingOp, 3, 4, "bool ?name?"},
    84618976    {"delete",    1, PolyDataDeleteOp, 2, 3, "?dataSetName?"},
     
    89499464    PseudoColor::ColorMode mode;
    89509465    const char *str = Tcl_GetString(objv[2]);
    8951     if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     9466    if (str[0] == 'c' &&
     9467        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    89529468        mode = PseudoColor::COLOR_CONSTANT;
    89539469    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    89639479    } else {
    89649480        Tcl_AppendResult(interp, "bad color mode option \"", str,
    8965                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     9481                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    89669482        return TCL_ERROR;
    89679483    }
     
    92099725    {"ccolor",       2, PseudoColorColorOp, 5, 6, "r g b ?dataSetName?"},
    92109726    {"cloudstyle",   2, PseudoColorCloudStyleOp, 3, 4, "style ?dataSetName?"},
     9727    {"color",        5, PseudoColorColorOp, 5, 6, "r g b ?dataSetName?"},
    92119728    {"colormap",     7, PseudoColorColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    92129729    {"colormode",    7, PseudoColorColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    986910386    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
    987010387        mode = Streamlines::COLOR_BY_VECTOR_Z;
    9871     } else if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     10388    } else if (str[0] == 'c' &&
     10389               (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    987210390        mode = Streamlines::COLOR_CONSTANT;
    987310391    } else {
    987410392        Tcl_AppendResult(interp, "bad color mode option \"", str,
    9875                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     10393                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    987610394        return TCL_ERROR;
    987710395    }
     
    1051811036static Rappture::CmdSpec streamlinesOps[] = {
    1051911037    {"add",          1, StreamlinesAddOp,            2, 3, "?dataSetName?"},
    10520     {"ccolor",       1, StreamlinesColorOp,          5, 6, "r g b ?dataSetName?"},
     11038    {"ccolor",       2, StreamlinesColorOp,          5, 6, "r g b ?dataSetName?"},
     11039    {"color",        5, StreamlinesColorOp,          5, 6, "r g b ?dataSetName?"},
    1052111040    {"colormap",     7, StreamlinesColorMapOp,       3, 4, "colorMapName ?dataSetName?"},
    1052211041    {"colormode",    7, StreamlinesColorModeOp,      4, 5, "mode fieldName ?dataSetName?"},
     
    1055511074
    1055611075static int
     11076Text3DAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11077            Tcl_Obj *const *objv)
     11078{
     11079    int fontSize;
     11080    const char *fontFamily = Tcl_GetString(objv[2]);
     11081    if (Tcl_GetIntFromObj(interp, objv[3], &fontSize) != TCL_OK) {
     11082        return TCL_ERROR;
     11083    }
     11084    const char *text = Tcl_GetString(objv[4]);
     11085    const char *name = Tcl_GetString(objv[5]);
     11086    if (!g_renderer->addText3D(name, text, fontFamily, fontSize)) {
     11087        Tcl_AppendResult(interp, "Failed to create text3d", (char*)NULL);
     11088        return TCL_ERROR;
     11089    }
     11090    return TCL_OK;
     11091}
     11092
     11093static int
     11094Text3DBoldOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11095             Tcl_Obj *const *objv)
     11096{
     11097    bool state;
     11098    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     11099        return TCL_ERROR;
     11100    }
     11101    if (objc == 4) {
     11102        const char *name = Tcl_GetString(objv[3]);
     11103        g_renderer->setText3DBold(name, state);
     11104    } else {
     11105        g_renderer->setText3DBold("all", state);
     11106    }
     11107    return TCL_OK;
     11108}
     11109
     11110static int
     11111Text3DColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11112              Tcl_Obj *const *objv)
     11113{
     11114    float color[3];
     11115    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
     11116        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
     11117        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
     11118        return TCL_ERROR;
     11119    }
     11120    if (objc == 6) {
     11121        const char *name = Tcl_GetString(objv[5]);
     11122        g_renderer->setGraphicsObjectColor<Text3D>(name, color);
     11123    } else {
     11124        g_renderer->setGraphicsObjectColor<Text3D>("all", color);
     11125    }
     11126    return TCL_OK;
     11127}
     11128
     11129static int
     11130Text3DDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11131               Tcl_Obj *const *objv)
     11132{
     11133    if (objc == 3) {
     11134        const char *name = Tcl_GetString(objv[2]);
     11135        g_renderer->deleteGraphicsObject<Text3D>(name);
     11136    } else {
     11137        g_renderer->deleteGraphicsObject<Text3D>("all");
     11138    }
     11139    return TCL_OK;
     11140}
     11141
     11142static int
     11143Text3DFollowCameraOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11144                     Tcl_Obj *const *objv)
     11145{
     11146    bool state;
     11147    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     11148        return TCL_ERROR;
     11149    }
     11150    if (objc == 4) {
     11151        const char *name = Tcl_GetString(objv[3]);
     11152        g_renderer->setText3DFollowCamera(name, state);
     11153    } else {
     11154        g_renderer->setText3DFollowCamera("all", state);
     11155    }
     11156    return TCL_OK;
     11157}
     11158
     11159static int
     11160Text3DFontFamilyOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11161                   Tcl_Obj *const *objv)
     11162{
     11163    const char *fontFamily = Tcl_GetString(objv[2]);
     11164    if (objc == 4) {
     11165        const char *name = Tcl_GetString(objv[3]);
     11166        g_renderer->setText3DFont(name, fontFamily);
     11167    } else {
     11168        g_renderer->setText3DFont("all", fontFamily);
     11169    }
     11170    return TCL_OK;
     11171}
     11172
     11173static int
     11174Text3DFontSizeOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11175                 Tcl_Obj *const *objv)
     11176{
     11177    int fontSize;
     11178    if (Tcl_GetIntFromObj(interp, objv[2], &fontSize) != TCL_OK) {
     11179        return TCL_ERROR;
     11180    }
     11181    if (objc == 4) {
     11182        const char *name = Tcl_GetString(objv[3]);
     11183        g_renderer->setText3DFontSize(name, fontSize);
     11184    } else {
     11185        g_renderer->setText3DFontSize("all", fontSize);
     11186    }
     11187    return TCL_OK;
     11188}
     11189
     11190static int
     11191Text3DItalicOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11192               Tcl_Obj *const *objv)
     11193{
     11194    bool state;
     11195    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     11196        return TCL_ERROR;
     11197    }
     11198    if (objc == 4) {
     11199        const char *name = Tcl_GetString(objv[3]);
     11200        g_renderer->setText3DItalic(name, state);
     11201    } else {
     11202        g_renderer->setText3DItalic("all", state);
     11203    }
     11204    return TCL_OK;
     11205}
     11206
     11207static int
     11208Text3DOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11209                Tcl_Obj *const *objv)
     11210{
     11211    double opacity;
     11212    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
     11213        return TCL_ERROR;
     11214    }
     11215    if (objc == 4) {
     11216        const char *name = Tcl_GetString(objv[3]);
     11217        g_renderer->setGraphicsObjectOpacity<Text3D>(name, opacity);
     11218    } else {
     11219        g_renderer->setGraphicsObjectOpacity<Text3D>("all", opacity);
     11220    }
     11221    return TCL_OK;
     11222}
     11223
     11224static int
     11225Text3DOrientOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11226               Tcl_Obj *const *objv)
     11227{
     11228    double quat[4];
     11229    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
     11230        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
     11231        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
     11232        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
     11233        return TCL_ERROR;
     11234    }
     11235    if (objc == 7) {
     11236        const char *name = Tcl_GetString(objv[6]);
     11237        g_renderer->setGraphicsObjectOrientation<Text3D>(name, quat);
     11238    } else {
     11239        g_renderer->setGraphicsObjectOrientation<Text3D>("all", quat);
     11240    }
     11241    return TCL_OK;
     11242}
     11243
     11244static int
     11245Text3DOriginOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11246               Tcl_Obj *const *objv)
     11247{
     11248    double origin[3];
     11249    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
     11250        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
     11251        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
     11252        return TCL_ERROR;
     11253    }
     11254    if (objc == 6) {
     11255        const char *name = Tcl_GetString(objv[5]);
     11256        g_renderer->setGraphicsObjectOrigin<Text3D>(name, origin);
     11257    } else {
     11258        g_renderer->setGraphicsObjectOrigin<Text3D>("all", origin);
     11259    }
     11260    return TCL_OK;
     11261}
     11262
     11263static int
     11264Text3DPositionOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11265                 Tcl_Obj *const *objv)
     11266{
     11267    double pos[3];
     11268    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
     11269        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
     11270        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
     11271        return TCL_ERROR;
     11272    }
     11273    if (objc == 6) {
     11274        const char *name = Tcl_GetString(objv[5]);
     11275        g_renderer->setGraphicsObjectPosition<Text3D>(name, pos);
     11276    } else {
     11277        g_renderer->setGraphicsObjectPosition<Text3D>("all", pos);
     11278    }
     11279    return TCL_OK;
     11280}
     11281
     11282static int
     11283Text3DScaleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11284              Tcl_Obj *const *objv)
     11285{
     11286    double scale[3];
     11287    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
     11288        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
     11289        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
     11290        return TCL_ERROR;
     11291    }
     11292    if (objc == 6) {
     11293        const char *name = Tcl_GetString(objv[5]);
     11294        g_renderer->setGraphicsObjectScale<Text3D>(name, scale);
     11295    } else {
     11296        g_renderer->setGraphicsObjectScale<Text3D>("all", scale);
     11297    }
     11298    return TCL_OK;
     11299}
     11300
     11301static int
     11302Text3DShadowOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11303               Tcl_Obj *const *objv)
     11304{
     11305    bool state;
     11306    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     11307        return TCL_ERROR;
     11308    }
     11309    if (objc == 4) {
     11310        const char *name = Tcl_GetString(objv[3]);
     11311        g_renderer->setText3DShadow(name, state);
     11312    } else {
     11313        g_renderer->setText3DShadow("all", state);
     11314    }
     11315    return TCL_OK;
     11316}
     11317
     11318static int
     11319Text3DTextOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11320             Tcl_Obj *const *objv)
     11321{
     11322    char *str = Tcl_GetString(objv[2]);
     11323    if (objc == 4) {
     11324        const char *name = Tcl_GetString(objv[3]);
     11325        g_renderer->setText3DText(name, str);
     11326    } else {
     11327        g_renderer->setText3DText("all", str);
     11328    }
     11329    return TCL_OK;
     11330}
     11331
     11332static int
     11333Text3DVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     11334                Tcl_Obj *const *objv)
     11335{
     11336    bool state;
     11337    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     11338        return TCL_ERROR;
     11339    }
     11340    if (objc == 4) {
     11341        const char *name = Tcl_GetString(objv[3]);
     11342        g_renderer->setGraphicsObjectVisibility<Text3D>(name, state);
     11343    } else {
     11344        g_renderer->setGraphicsObjectVisibility<Text3D>("all", state);
     11345    }
     11346    return TCL_OK;
     11347}
     11348
     11349static Rappture::CmdSpec text3DOps[] = {
     11350    {"add",       1, Text3DAddOp, 6, 6, "font size text name"},
     11351    {"bold",      1, Text3DBoldOp, 3, 4, "bool ?name?"},
     11352    {"color",     1, Text3DColorOp, 5, 6, "r g b ?name?"},
     11353    {"delete",    1, Text3DDeleteOp, 2, 3, "?name?"},
     11354    {"fntfamily", 4, Text3DFontFamilyOp, 3, 4, "font ?name?"},
     11355    {"fntsize",   4, Text3DFontSizeOp, 3, 4, "size ?name?"},
     11356    {"followcam", 2, Text3DFollowCameraOp, 3, 4, "bool ?name?"},
     11357    {"italic",    1, Text3DItalicOp, 3, 4, "bool ?name?"},
     11358    {"opacity",   2, Text3DOpacityOp, 3, 4, "value ?name?"},
     11359    {"orient",    4, Text3DOrientOp, 6, 7, "qw qx qy qz ?name?"},
     11360    {"origin",    4, Text3DOriginOp, 5, 6, "x y z ?name?"},
     11361    {"pos",       1, Text3DPositionOp, 5, 6, "x y z ?name?"},
     11362    {"scale",     1, Text3DScaleOp, 5, 6, "sx sy sz ?name?"},
     11363    {"shadow",    1, Text3DShadowOp, 3, 4, "bool ?name?"},
     11364    {"text",      1, Text3DTextOp, 3, 4, "text ?name?"},
     11365    {"visible",   1, Text3DVisibleOp, 3, 4, "bool ?name?"},
     11366};
     11367static int nText3DOps = NumCmdSpecs(text3DOps);
     11368
     11369static int
     11370Text3DCmd(ClientData clientData, Tcl_Interp *interp, int objc,
     11371          Tcl_Obj *const *objv)
     11372{
     11373    Tcl_ObjCmdProc *proc;
     11374
     11375    proc = Rappture::GetOpFromObj(interp, nText3DOps, text3DOps,
     11376                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
     11377    if (proc == NULL) {
     11378        return TCL_ERROR;
     11379    }
     11380    return (*proc) (clientData, interp, objc, objv);
     11381}
     11382
     11383static int
    1055711384VolumeAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
    1055811385            Tcl_Obj *const *objv)
     
    1092711754    Warp::ColorMode mode;
    1092811755    const char *str = Tcl_GetString(objv[2]);
    10929     if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
     11756    if (str[0] == 'c' &&
     11757        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
    1093011758        mode = Warp::COLOR_CONSTANT;
    1093111759    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
     
    1094111769    } else {
    1094211770        Tcl_AppendResult(interp, "bad color mode option \"", str,
    10943                          "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
     11771                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
    1094411772        return TCL_ERROR;
    1094511773    }
     
    1120412032    {"ccolor",       2, WarpColorOp, 5, 6, "r g b ?dataSetName?"},
    1120512033    {"cloudstyle",   2, WarpCloudStyleOp, 3, 4, "style ?dataSetName?"},
     12034    {"color",        5, WarpColorOp, 5, 6, "r g b ?dataSetName?"},
    1120612035    {"colormap",     7, WarpColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
    1120712036    {"colormode",    7, WarpColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     
    1139812227    Tcl_CreateObjCommand(interp, "group",       GroupCmd,       clientData, NULL);
    1139912228    Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   clientData, NULL);
     12229    Tcl_CreateObjCommand(interp, "image",       ImageCmd,       clientData, NULL);
    1140012230    Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  clientData, NULL);
    1140112231    Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      clientData, NULL);
     12232    Tcl_CreateObjCommand(interp, "legend2",     LegendSimpleCmd,clientData, NULL);
    1140212233    Tcl_CreateObjCommand(interp, "lic",         LICCmd,         clientData, NULL);
    1140312234    Tcl_CreateObjCommand(interp, "line",        LineCmd,        clientData, NULL);
     
    1141112242    Tcl_CreateObjCommand(interp, "sphere",      SphereCmd,      clientData, NULL);
    1141212243    Tcl_CreateObjCommand(interp, "streamlines", StreamlinesCmd, clientData, NULL);
     12244    Tcl_CreateObjCommand(interp, "text3d",      Text3DCmd,      clientData, NULL);
    1141312245    Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      clientData, NULL);
    1141412246    Tcl_CreateObjCommand(interp, "warp",        WarpCmd,        clientData, NULL);
     
    1143712269    Tcl_DeleteCommand(interp, "group");
    1143812270    Tcl_DeleteCommand(interp, "heightmap");
     12271    Tcl_DeleteCommand(interp, "image");
    1143912272    Tcl_DeleteCommand(interp, "imgflush");
    1144012273    Tcl_DeleteCommand(interp, "legend");
     12274    Tcl_DeleteCommand(interp, "legend2");
    1144112275    Tcl_DeleteCommand(interp, "lic");
    1144212276    Tcl_DeleteCommand(interp, "line");
     
    1145012284    Tcl_DeleteCommand(interp, "sphere");
    1145112285    Tcl_DeleteCommand(interp, "streamlines");
     12286    Tcl_DeleteCommand(interp, "text3d");
    1145212287    Tcl_DeleteCommand(interp, "volume");
    1145312288    Tcl_DeleteCommand(interp, "warp");
  • trunk/packages/vizservers/vtkvis/RendererGraphicsObjs.cpp

    r3771 r3818  
    100100
    101101template<>
     102Renderer::ImageHashmap &
     103Renderer::getGraphicsObjectHashmap<Image>()
     104{ return _images; }
     105
     106template<>
    102107Renderer::LICHashmap &
    103108Renderer::getGraphicsObjectHashmap<LIC>()
     
    145150
    146151template<>
     152Renderer::Text3DHashmap &
     153Renderer::getGraphicsObjectHashmap<Text3D>()
     154{ return _text3Ds; }
     155
     156template<>
    147157Renderer::VolumeHashmap &
    148158Renderer::getGraphicsObjectHashmap<Volume>()
     
    154164{ return _warps; }
    155165
     166#if 0
    156167template Arc *Renderer::getGraphicsObject(const DataSetId&);
    157168template Arrow *Renderer::getGraphicsObject(const DataSetId&);
     
    164175template Polygon *Renderer::getGraphicsObject(const DataSetId&);
    165176template Sphere *Renderer::getGraphicsObject(const DataSetId&);
     177template Text3D *Renderer::getGraphicsObject(const DataSetId&);
     178#endif
    166179
    167180template <>
     
    214227}
    215228
    216 template <>
    217 bool Renderer::addGraphicsObject<Box>(const DataSetId& id)
    218 {
    219     Box *gobj;
    220     if ((gobj = getGraphicsObject<Box>(id)) != NULL) {
    221         WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
    222         deleteGraphicsObject<Box>(id);
    223     }
    224 
    225     gobj = new Box();
    226  
    227     gobj->setDataSet(NULL, this);
    228 
    229     if (gobj->getProp() == NULL &&
    230         gobj->getOverlayProp() == NULL) {
    231         delete gobj;
    232         return false;
    233     } else {
    234         if (gobj->getProp())
    235             _renderer->AddViewProp(gobj->getProp());
    236         if (gobj->getOverlayProp())
    237             _renderer->AddViewProp(gobj->getOverlayProp());
    238     }
    239 
    240     getGraphicsObjectHashmap<Box>()[id] = gobj;
    241 
    242     sceneBoundsChanged();
    243     _needsRedraw = true;
    244     return true;
    245 }
    246 
    247 template <>
    248 bool Renderer::addGraphicsObject<Sphere>(const DataSetId& id)
    249 {
    250     Sphere *gobj;
    251     if ((gobj = getGraphicsObject<Sphere>(id)) != NULL) {
    252         WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
    253         deleteGraphicsObject<Sphere>(id);
    254     }
    255 
    256     gobj = new Sphere();
    257  
    258     gobj->setDataSet(NULL, this);
    259 
    260     if (gobj->getProp() == NULL &&
    261         gobj->getOverlayProp() == NULL) {
    262         delete gobj;
    263         return false;
    264     } else {
    265         if (gobj->getProp())
    266             _renderer->AddViewProp(gobj->getProp());
    267         if (gobj->getOverlayProp())
    268             _renderer->AddViewProp(gobj->getOverlayProp());
    269     }
    270 
    271     getGraphicsObjectHashmap<Sphere>()[id] = gobj;
    272 
    273     sceneBoundsChanged();
    274     _needsRedraw = true;
    275     return true;
    276 }
    277 
    278229/**
    279230 * \brief Set the volume slice used for mapping volumetric data
     
    342293    }
    343294    if ((gobj = getGraphicsObject<Sphere>(id)) != NULL) {
     295        return gobj;
     296    }
     297    if ((gobj = getGraphicsObject<Text3D>(id)) != NULL) {
    344298        return gobj;
    345299    }
     
    358312    }
    359313    if ((gobj = getGraphicsObject<HeightMap>(id)) != NULL) {
     314        return gobj;
     315    }
     316    if ((gobj = getGraphicsObject<Image>(id)) != NULL) {
    360317        return gobj;
    361318    }
     
    23082265}
    23092266
     2267void Renderer::setImageBackground(const DataSetId& id, bool state)
     2268{
     2269    ImageHashmap::iterator itr;
     2270
     2271    bool doAll = false;
     2272
     2273    if (id.compare("all") == 0) {
     2274        itr = _images.begin();
     2275        if (itr == _images.end())
     2276            return;
     2277        doAll = true;
     2278    } else {
     2279        itr = _images.find(id);
     2280    }
     2281    if (itr == _images.end()) {
     2282        ERROR("Image not found: %s", id.c_str());
     2283        return;
     2284    }
     2285
     2286    do {
     2287        itr->second->setBackground(state);
     2288    } while (doAll && ++itr != _images.end());
     2289
     2290    _needsRedraw = true;
     2291}
     2292
     2293void Renderer::setImageBacking(const DataSetId& id, bool state)
     2294{
     2295    ImageHashmap::iterator itr;
     2296
     2297    bool doAll = false;
     2298
     2299    if (id.compare("all") == 0) {
     2300        itr = _images.begin();
     2301        if (itr == _images.end())
     2302            return;
     2303        doAll = true;
     2304    } else {
     2305        itr = _images.find(id);
     2306    }
     2307    if (itr == _images.end()) {
     2308        ERROR("Image not found: %s", id.c_str());
     2309        return;
     2310    }
     2311
     2312    do {
     2313        itr->second->setBacking(state);
     2314    } while (doAll && ++itr != _images.end());
     2315
     2316    _needsRedraw = true;
     2317}
     2318
     2319void Renderer::setImageBorder(const DataSetId& id, bool state)
     2320{
     2321    ImageHashmap::iterator itr;
     2322
     2323    bool doAll = false;
     2324
     2325    if (id.compare("all") == 0) {
     2326        itr = _images.begin();
     2327        if (itr == _images.end())
     2328            return;
     2329        doAll = true;
     2330    } else {
     2331        itr = _images.find(id);
     2332    }
     2333    if (itr == _images.end()) {
     2334        ERROR("Image not found: %s", id.c_str());
     2335        return;
     2336    }
     2337
     2338    do {
     2339        itr->second->setBorder(state);
     2340    } while (doAll && ++itr != _images.end());
     2341
     2342    _needsRedraw = true;
     2343}
     2344
     2345void Renderer::setImageExtents(const DataSetId& id, int extents[6])
     2346{
     2347    ImageHashmap::iterator itr;
     2348
     2349    bool doAll = false;
     2350
     2351    if (id.compare("all") == 0) {
     2352        itr = _images.begin();
     2353        if (itr == _images.end())
     2354            return;
     2355        doAll = true;
     2356    } else {
     2357        itr = _images.find(id);
     2358    }
     2359    if (itr == _images.end()) {
     2360        ERROR("Image not found: %s", id.c_str());
     2361        return;
     2362    }
     2363
     2364    do {
     2365        itr->second->setExtents(extents);
     2366    } while (doAll && ++itr != _images.end());
     2367
     2368    _needsRedraw = true;
     2369}
     2370
     2371void Renderer::setImageLevel(const DataSetId& id, double level)
     2372{
     2373    ImageHashmap::iterator itr;
     2374
     2375    bool doAll = false;
     2376
     2377    if (id.compare("all") == 0) {
     2378        itr = _images.begin();
     2379        if (itr == _images.end())
     2380            return;
     2381        doAll = true;
     2382    } else {
     2383        itr = _images.find(id);
     2384    }
     2385    if (itr == _images.end()) {
     2386        ERROR("Image not found: %s", id.c_str());
     2387        return;
     2388    }
     2389
     2390    do {
     2391        itr->second->setLevel(level);
     2392    } while (doAll && ++itr != _images.end());
     2393
     2394    _needsRedraw = true;
     2395}
     2396
     2397void Renderer::setImageWindow(const DataSetId& id, double window)
     2398{
     2399    ImageHashmap::iterator itr;
     2400
     2401    bool doAll = false;
     2402
     2403    if (id.compare("all") == 0) {
     2404        itr = _images.begin();
     2405        if (itr == _images.end())
     2406            return;
     2407        doAll = true;
     2408    } else {
     2409        itr = _images.find(id);
     2410    }
     2411    if (itr == _images.end()) {
     2412        ERROR("Image not found: %s", id.c_str());
     2413        return;
     2414    }
     2415
     2416    do {
     2417        itr->second->setWindow(window);
     2418    } while (doAll && ++itr != _images.end());
     2419
     2420    _needsRedraw = true;
     2421}
     2422
     2423void Renderer::setImageZSlice(const DataSetId& id, int z)
     2424{
     2425    ImageHashmap::iterator itr;
     2426
     2427    bool doAll = false;
     2428
     2429    if (id.compare("all") == 0) {
     2430        itr = _images.begin();
     2431        if (itr == _images.end())
     2432            return;
     2433        doAll = true;
     2434    } else {
     2435        itr = _images.find(id);
     2436    }
     2437    if (itr == _images.end()) {
     2438        ERROR("Image not found: %s", id.c_str());
     2439        return;
     2440    }
     2441
     2442    do {
     2443        itr->second->setZSlice(z);
     2444    } while (doAll && ++itr != _images.end());
     2445
     2446    _needsRedraw = true;
     2447}
     2448
    23102449/**
    23112450 * \brief Create a new Line and associate it with an ID
     
    28683007
    28693008/**
     3009 * \brief Set the color mode for the specified DataSet
     3010 */
     3011void Renderer::setPolyDataColorMode(const DataSetId& id,
     3012                                    PolyData::ColorMode mode,
     3013                                    DataSet::DataAttributeType type,
     3014                                    const char *name, double range[2])
     3015{
     3016    PolyDataHashmap::iterator itr;
     3017
     3018    bool doAll = false;
     3019
     3020    if (id.compare("all") == 0) {
     3021        itr = _polyDatas.begin();
     3022        if (itr == _polyDatas.end())
     3023            return;
     3024        doAll = true;
     3025    } else {
     3026        itr = _polyDatas.find(id);
     3027    }
     3028    if (itr == _polyDatas.end()) {
     3029        ERROR("PolyData not found: %s", id.c_str());
     3030        return;
     3031    }
     3032
     3033    do {
     3034        itr->second->setColorMode(mode, type, name, range);
     3035    } while (doAll && ++itr != _polyDatas.end());
     3036
     3037    _needsRedraw = true;
     3038}
     3039
     3040/**
     3041 * \brief Set the color mode for the specified DataSet
     3042 */
     3043void Renderer::setPolyDataColorMode(const DataSetId& id,
     3044                                    PolyData::ColorMode mode,
     3045                                    const char *name, double range[2])
     3046{
     3047    PolyDataHashmap::iterator itr;
     3048
     3049    bool doAll = false;
     3050
     3051    if (id.compare("all") == 0) {
     3052        itr = _polyDatas.begin();
     3053        if (itr == _polyDatas.end())
     3054            return;
     3055        doAll = true;
     3056    } else {
     3057        itr = _polyDatas.find(id);
     3058    }
     3059    if (itr == _polyDatas.end()) {
     3060        ERROR("PolyData not found: %s", id.c_str());
     3061        return;
     3062    }
     3063
     3064    do {
     3065        itr->second->setColorMode(mode, name, range);
     3066    } while (doAll && ++itr != _polyDatas.end());
     3067
     3068    _needsRedraw = true;
     3069}
     3070
     3071/**
    28703072 * \brief Set the  point cloud render style for the specified DataSet
    28713073 */
     
    29923194
    29933195    getGraphicsObjectHashmap<Sphere>()[id] = gobj;
     3196
     3197    sceneBoundsChanged();
     3198    _needsRedraw = true;
     3199    return true;
     3200}
     3201
     3202/**
     3203 * \brief Create a new Text3D label and associate it with an ID
     3204 */
     3205bool Renderer::addText3D(const DataSetId& id, const char *string,
     3206                         const char *fontFamily, int fontSize,
     3207                         bool bold, bool italic, bool shadow)
     3208{
     3209    Text3D *gobj;
     3210    if ((gobj = getGraphicsObject<Text3D>(id)) != NULL) {
     3211        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
     3212        deleteGraphicsObject<Text3D>(id);
     3213    }
     3214
     3215    gobj = new Text3D();
     3216
     3217    gobj->setDataSet(NULL, this);
     3218
     3219    gobj->setText(string);
     3220    gobj->setFont(fontFamily);
     3221    gobj->setFontSize(fontSize);
     3222    gobj->setBold(bold);
     3223    gobj->setItalic(italic);
     3224    gobj->setShadow(shadow);
     3225
     3226    if (gobj->getProp() == NULL &&
     3227        gobj->getOverlayProp() == NULL) {
     3228        delete gobj;
     3229        return false;
     3230    } else {
     3231        if (gobj->getProp())
     3232            _renderer->AddViewProp(gobj->getProp());
     3233        if (gobj->getOverlayProp())
     3234            _renderer->AddViewProp(gobj->getOverlayProp());
     3235    }
     3236
     3237    getGraphicsObjectHashmap<Text3D>()[id] = gobj;
    29943238
    29953239    sceneBoundsChanged();
     
    36943938}
    36953939
     3940void Renderer::setText3DBold(const DataSetId& id, bool state)
     3941{
     3942    Text3DHashmap::iterator itr;
     3943
     3944    bool doAll = false;
     3945
     3946    if (id.compare("all") == 0) {
     3947        itr = _text3Ds.begin();
     3948        if (itr == _text3Ds.end())
     3949            return;
     3950        doAll = true;
     3951    } else {
     3952        itr = _text3Ds.find(id);
     3953    }
     3954    if (itr == _text3Ds.end()) {
     3955        ERROR("Text3D not found: %s", id.c_str());
     3956        return;
     3957    }
     3958
     3959    do {
     3960        itr->second->setBold(state);
     3961    } while (doAll && ++itr != _text3Ds.end());
     3962
     3963    sceneBoundsChanged();
     3964    _needsRedraw = true;
     3965}
     3966
     3967/**
     3968 * \brief Set the font family for the Text3D
     3969 */
     3970void Renderer::setText3DFont(const DataSetId& id, const char *fontFamily)
     3971{
     3972    Text3DHashmap::iterator itr;
     3973
     3974    bool doAll = false;
     3975
     3976    if (id.compare("all") == 0) {
     3977        itr = _text3Ds.begin();
     3978        if (itr == _text3Ds.end())
     3979            return;
     3980        doAll = true;
     3981    } else {
     3982        itr = _text3Ds.find(id);
     3983    }
     3984    if (itr == _text3Ds.end()) {
     3985        ERROR("Text3D not found: %s", id.c_str());
     3986        return;
     3987    }
     3988
     3989    do {
     3990        itr->second->setFont(fontFamily);
     3991    } while (doAll && ++itr != _text3Ds.end());
     3992
     3993    sceneBoundsChanged();
     3994    _needsRedraw = true;
     3995}
     3996
     3997/**
     3998 * \brief Set the font family for the Text3D
     3999 */
     4000void Renderer::setText3DFontSize(const DataSetId& id, int size)
     4001{
     4002    Text3DHashmap::iterator itr;
     4003
     4004    bool doAll = false;
     4005
     4006    if (id.compare("all") == 0) {
     4007        itr = _text3Ds.begin();
     4008        if (itr == _text3Ds.end())
     4009            return;
     4010        doAll = true;
     4011    } else {
     4012        itr = _text3Ds.find(id);
     4013    }
     4014    if (itr == _text3Ds.end()) {
     4015        ERROR("Text3D not found: %s", id.c_str());
     4016        return;
     4017    }
     4018
     4019    do {
     4020        itr->second->setFontSize(size);
     4021    } while (doAll && ++itr != _text3Ds.end());
     4022
     4023    sceneBoundsChanged();
     4024    _needsRedraw = true;
     4025}
     4026
     4027void Renderer::setText3DFollowCamera(const DataSetId& id, bool state)
     4028{
     4029    Text3DHashmap::iterator itr;
     4030
     4031    bool doAll = false;
     4032
     4033    if (id.compare("all") == 0) {
     4034        itr = _text3Ds.begin();
     4035        if (itr == _text3Ds.end())
     4036            return;
     4037        doAll = true;
     4038    } else {
     4039        itr = _text3Ds.find(id);
     4040    }
     4041    if (itr == _text3Ds.end()) {
     4042        ERROR("Text3D not found: %s", id.c_str());
     4043        return;
     4044    }
     4045
     4046    do {
     4047        itr->second->setFollowCamera(state, _renderer);
     4048    } while (doAll && ++itr != _text3Ds.end());
     4049
     4050    sceneBoundsChanged();
     4051    _needsRedraw = true;
     4052}
     4053
     4054void Renderer::setText3DItalic(const DataSetId& id, bool state)
     4055{
     4056    Text3DHashmap::iterator itr;
     4057
     4058    bool doAll = false;
     4059
     4060    if (id.compare("all") == 0) {
     4061        itr = _text3Ds.begin();
     4062        if (itr == _text3Ds.end())
     4063            return;
     4064        doAll = true;
     4065    } else {
     4066        itr = _text3Ds.find(id);
     4067    }
     4068    if (itr == _text3Ds.end()) {
     4069        ERROR("Text3D not found: %s", id.c_str());
     4070        return;
     4071    }
     4072
     4073    do {
     4074        itr->second->setItalic(state);
     4075    } while (doAll && ++itr != _text3Ds.end());
     4076
     4077    sceneBoundsChanged();
     4078    _needsRedraw = true;
     4079}
     4080
     4081void Renderer::setText3DShadow(const DataSetId& id, bool state)
     4082{
     4083    Text3DHashmap::iterator itr;
     4084
     4085    bool doAll = false;
     4086
     4087    if (id.compare("all") == 0) {
     4088        itr = _text3Ds.begin();
     4089        if (itr == _text3Ds.end())
     4090            return;
     4091        doAll = true;
     4092    } else {
     4093        itr = _text3Ds.find(id);
     4094    }
     4095    if (itr == _text3Ds.end()) {
     4096        ERROR("Text3D not found: %s", id.c_str());
     4097        return;
     4098    }
     4099
     4100    do {
     4101        itr->second->setShadow(state);
     4102    } while (doAll && ++itr != _text3Ds.end());
     4103
     4104    sceneBoundsChanged();
     4105    _needsRedraw = true;
     4106}
     4107
     4108void Renderer::setText3DText(const DataSetId& id, const char *text)
     4109{
     4110    Text3DHashmap::iterator itr;
     4111
     4112    bool doAll = false;
     4113
     4114    if (id.compare("all") == 0) {
     4115        itr = _text3Ds.begin();
     4116        if (itr == _text3Ds.end())
     4117            return;
     4118        doAll = true;
     4119    } else {
     4120        itr = _text3Ds.find(id);
     4121    }
     4122    if (itr == _text3Ds.end()) {
     4123        ERROR("Text3D not found: %s", id.c_str());
     4124        return;
     4125    }
     4126
     4127    do {
     4128        itr->second->setText(text);
     4129    } while (doAll && ++itr != _text3Ds.end());
     4130
     4131    sceneBoundsChanged();
     4132    _needsRedraw = true;
     4133}
     4134
    36964135/**
    36974136 * \brief Set the sample rate for the volume shader
  • trunk/packages/vizservers/vtkvis/protocol.txt

    r3798 r3818  
    573573heightmap wireframe <bool> <?datasetName?>
    574574
     575image add <?dataSetName?>
     576      Create an image from a vtkImageData data set
     577image backing <bool> <?dataSetName?>
     578image bg <bool> <?dataSetName?>
     579image border <bool> <?dataSetName?>
     580image color <r> <g> <b> <?dataSetName?>
     581image colormap <colorMapName> <?dataSetName?>
     582image delete <?dataSetName?>
     583image extents <xmin> <xmax> <ymin> <ymax> <zmin> <zmax> <?dataSetName?>
     584image level <level> <?dataSetName?>
     585image opacity <opacity> <?dataSetName?>
     586image orient <qw> <qx> <qy> <qz> <?dataSetName?>
     587image pos <x> <y> <z> <?dataSetName?>
     588image scale <sx> <sy> <sz> <?dataSetName?>
     589image visible <bool> <?dataSetName?>
     590image window <windowWidth> <?dataSetName?>
     591image zslice <sliceNum> <?dataSetName?>
     592
    575593lic add <?datasetName?>
    576594lic colormap <colormapName> <?datasetName?>
     
    669687
    670688polydata add <?datasetName?>
     689polydata ccolor <r> <g> <b> <?datasetName?>
    671690polydata cloudstyle <style> <?datasetName?>
    672691         <style> = mesh | points
    673 polydata color <r> <g> <b> <?datasetName?>
     692polydata colormap <colormapName> <?datasetName?>
     693polydata colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
     694         Set the field used to color the object.  'ccolor' means to use
     695         the constant color defined by the ccolor subcommand.  'scalar' uses
     696         the active scalar field.  'vmag' uses the magnitude of the current
     697         vector field, and 'vx','vy','vz' use the corresponding component of
     698         the active vector field.
    674699polydata culling <bool> <?name?>
    675700polydata delete <?datasetName?>
     
    826851streamlines visible <bool> <?datasetName?>
    827852
     853text3d add <textString> <name>
     854text3d color <r> <g> <b> <?name?>
     855text3d delete <?name?>
     856text3d fntfamily <fontName> <?name?>
     857text3d fntsize <fontSize> <?name?>
     858text3d opacity <opacity> <?name?>
     859text3d orient <qw> <qx> <qy> <qz> <?name?>
     860text3d origin <x> <y> <z> <?name?>
     861text3d pos <x> <y> <z> <?name?>
     862text3d scale <sx> <sy> <sz> <?name?>
     863text3d visible <bool> <?name?>
     864
    828865volume add <?datasetName?>
    829866volume colormap <colorMapName> <?datasetName?>
Note: See TracChangeset for help on using the changeset viewer.