Changeset 3189


Ignore:
Timestamp:
Nov 15, 2012 6:18:44 PM (11 years ago)
Author:
ldelgass
Message:

Adopt API changes for upcoming VTK 6.0

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

Legend:

Unmodified
Added
Removed

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

    r3177 r3189  
    88#include <cfloat>
    99
     10#include <vtkVersion.h>
     11#if (VTK_MAJOR_VERSION >= 6)
     12#define USE_VTK6
     13#endif
    1014#include <vtkDataSet.h>
    1115#include <vtkPointData.h>
    … …  
    127131            cellToPtData =
    128132                vtkSmartPointer<vtkCellDataToPointData>::New();
     133#ifdef USE_VTK6
     134            cellToPtData->SetInputData(ds);
     135#else
    129136            cellToPtData->SetInput(ds);
     137#endif
    130138            //cellToPtData->PassCellDataOn();
    131139            cellToPtData->Update();
    … …  
    167175                    mesher->SetTransform(trans);
    168176                }
     177#ifdef USE_VTK6
     178                mesher->SetInputData(pd);
     179#else
    169180                mesher->SetInput(pd);
     181#endif
    170182                _contourFilter->SetInputConnection(mesher->GetOutputPort());
    171183            } else {
    172184                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     185#ifdef USE_VTK6
     186                mesher->SetInputData(pd);
     187#else
    173188                mesher->SetInput(pd);
     189#endif
    174190                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    175191                gf->SetInputConnection(mesher->GetOutputPort());
    … …  
    178194        } else {
    179195            // DataSet is a vtkPolyData with lines and/or polygons
     196#ifdef USE_VTK6
     197            _contourFilter->SetInputData(ds);
     198#else
    180199            _contourFilter->SetInput(ds);
     200#endif
    181201        }
    182202    } else {
    … …  
    184204        // DataSet is NOT a vtkPolyData
    185205        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     206#ifdef USE_VTK6
     207        gf->SetInputData(ds);
     208#else
    186209        gf->SetInput(ds);
     210#endif
    187211        _contourFilter->SetInputConnection(gf->GetOutputPort());
    188212    }

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

    r3177 r3189  
    88#include <cassert>
    99
     10#include <vtkVersion.h>
     11#if (VTK_MAJOR_VERSION >= 6)
     12#define USE_VTK6
     13#endif
    1014#include <vtkDataSet.h>
    1115#include <vtkPointData.h>
    … …  
    117121            cellToPtData =
    118122                vtkSmartPointer<vtkCellDataToPointData>::New();
     123#ifdef USE_VTK6
     124            cellToPtData->SetInputData(ds);
     125#else
    119126            cellToPtData->SetInput(ds);
     127#endif
    120128            //cellToPtData->PassCellDataOn();
    121129            cellToPtData->Update();
    … …  
    135143            // Generate a 3D unstructured grid
    136144            vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     145#ifdef USE_VTK6
     146            mesher->SetInputData(pd);
     147#else
    137148            mesher->SetInput(pd);
     149#endif
    138150            _contourFilter->SetInputConnection(mesher->GetOutputPort());
    139151        } else {
    … …  
    144156    } else {
    145157         // DataSet is NOT a vtkPolyData
     158#ifdef USE_VTK6
     159         _contourFilter->SetInputData(ds);
     160#else
    146161         _contourFilter->SetInput(ds);
     162#endif
    147163    }
    148164

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

    r3178 r3189  
    1010#include <cstring>
    1111
     12#include <vtkVersion.h>
     13#if (VTK_MAJOR_VERSION >= 6)
     14#define USE_VTK6
     15#endif
    1216#include <vtkDataSet.h>
    1317#include <vtkPointData.h>
    … …  
    226230                _actor[1]->VisibilityOff();
    227231            }
     232#ifdef USE_VTK6
     233            mesher->SetInputData(pd);
     234#else
    228235            mesher->SetInput(pd);
     236#endif
    229237            for (int i = 0; i < 3; i++) {
    230238                _mapper[i]->SetInputConnection(mesher->GetOutputPort());
    … …  
    234242                _splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    235243            }
     244#ifdef USE_VTK6
     245            _splatter->SetInputData(pd);
     246#else
    236247            _splatter->SetInput(pd);
     248#endif
    237249            int dims[3];
    238250            _splatter->GetSampleDimensions(dims);
    … …  
    259271            // Result of Delaunay3D mesher is unstructured grid
    260272            vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     273#ifdef USE_VTK6
     274            mesher->SetInputData(pd);
     275#else
    261276            mesher->SetInput(pd);
     277#endif
    262278            // Sample a plane within the grid bounding box
    263279            for (int i = 0; i < 3; i++) {
    … …  
    272288                _splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    273289            }
     290#ifdef USE_VTK6
     291            _splatter->SetInputData(pd);
     292#else
    274293            _splatter->SetInput(pd);
     294#endif
    275295            int dims[3];
    276296            dims[0] = dims[1] = dims[2] = 64;
    … …  
    295315            // Sample a plane within the grid bounding box
    296316            for (int i = 0; i < 3; i++) {
     317#ifdef USE_VTK6
     318                _cutter[i]->SetInputData(ds);
     319#else
    297320                _cutter[i]->SetInput(ds);
     321#endif
    298322                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    299323                gf->UseStripsOn();
    … …  
    317341                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    318342                gf->UseStripsOn();
     343#ifdef USE_VTK6
     344                gf->SetInputData(ds);
     345#else
    319346                gf->SetInput(ds);
     347#endif
    320348                _mapper[i]->SetInputConnection(gf->GetOutputPort());
    321349            }

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

    r3177 r3189  
    99#include <cfloat>
    1010
     11#include <vtkVersion.h>
     12#if (VTK_MAJOR_VERSION >= 6)
     13#define USE_VTK6
     14#endif
    1115#include <vtkDataSet.h>
    1216#include <vtkPointData.h>
    … …  
    211215        break;
    212216    case CYLINDER: {
    213         assert (vtkTransformPolyDataFilter::SafeDownCast(_glyphSource) != NULL);
    214         assert (vtkTransformPolyDataFilter::SafeDownCast(_glyphSource)->GetInput() != NULL);
    215         TRACE("gsource input: %s", vtkTransformPolyDataFilter::SafeDownCast(_glyphSource)->GetInput()->GetClassName());
    216         vtkSmartPointer<vtkCylinderSource> csource = vtkCylinderSource::SafeDownCast(vtkTransformPolyDataFilter::SafeDownCast(_glyphSource)->GetInput()->GetProducerPort());
     217        assert(vtkTransformPolyDataFilter::SafeDownCast(_glyphSource) != NULL);
     218        assert(vtkTransformPolyDataFilter::SafeDownCast(_glyphSource)->GetInputConnection(0, 0) != NULL);
     219        vtkSmartPointer<vtkCylinderSource> csource = vtkCylinderSource::SafeDownCast(vtkTransformPolyDataFilter::SafeDownCast(_glyphSource)->GetInputConnection(0, 0));
    217220        int res = (int)(quality * 25);
    218221        if (res < 5) res = 5;
    … …  
    267270            cellToPtData =
    268271                vtkSmartPointer<vtkCellDataToPointData>::New();
     272#ifdef USE_VTK6
     273            cellToPtData->SetInputData(ds);
     274#else
    269275            cellToPtData->SetInput(ds);
     276#endif
    270277            //cellToPtData->PassCellDataOn();
    271278            cellToPtData->Update();
    … …  
    277284
    278285#ifdef HAVE_GLYPH3D_MAPPER
    279     _glyphMapper->SetInputConnection(ds->GetProducerPort());
     286#ifdef USE_VTK6
     287    _glyphMapper->SetInputData(ds);
     288#else
     289    _glyphMapper->SetInput(ds);
     290#endif
    280291#else
    281292    _glyphGenerator->SetInput(ds);

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

    r3177 r3189  
    88#include <cassert>
    99
     10#include <vtkVersion.h>
     11#if (VTK_MAJOR_VERSION >= 6)
     12#define USE_VTK6
     13#endif
    1014#include <vtkDataSet.h>
    1115#include <vtkPointData.h>
    … …  
    189193                cellToPtData =
    190194                    vtkSmartPointer<vtkCellDataToPointData>::New();
     195#ifdef USE_VTK6
     196                cellToPtData->SetInputData(ds);
     197#else
    191198                cellToPtData->SetInput(ds);
     199#endif
    192200                //cellToPtData->PassCellDataOn();
    193201                cellToPtData->Update();
    … …  
    234242                        mesher->SetTransform(trans);
    235243                    }
     244#ifdef USE_VTK6
     245                    mesher->SetInputData(pd);
     246#else
    236247                    mesher->SetInput(pd);
     248#endif
    237249                    vtkAlgorithmOutput *warpOutput = initWarp(mesher->GetOutputPort());
    238250                    _dsMapper->SetInputConnection(warpOutput);
    … …  
    243255                    if (_volumeSlicer == NULL)
    244256                        _volumeSlicer = vtkSmartPointer<vtkExtractVOI>::New();
     257#ifdef USE_VTK6
     258                    _pointSplatter->SetInputData(pd);
     259#else
    245260                    _pointSplatter->SetInput(pd);
     261#endif
    246262                    int dims[3];
    247263                    _pointSplatter->GetSampleDimensions(dims);
    … …  
    281297                    // Result of Delaunay3D mesher is unstructured grid
    282298                    vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     299#ifdef USE_VTK6
     300                    mesher->SetInputData(pd);
     301#else
    283302                    mesher->SetInput(pd);
     303#endif
    284304                    // Run the mesher
    285305                    mesher->Update();
    … …  
    304324                    if (_pointSplatter == NULL)
    305325                        _pointSplatter = vtkSmartPointer<vtkGaussianSplatter>::New();
     326#ifdef USE_VTK6
     327                    _pointSplatter->SetInputData(pd);
     328#else
    306329                    _pointSplatter->SetInput(pd);
     330#endif
    307331                    int dims[3];
    308332                    _pointSplatter->GetSampleDimensions(dims);
    … …  
    337361                    _contourFilter->SetInputConnection(warpOutput);
    338362                } else {
     363#ifdef USE_VTK6
     364                    _dsMapper->SetInputData(pd);
     365                    _contourFilter->SetInputData(pd);
     366#else
    339367                    _dsMapper->SetInput(pd);
    340368                    _contourFilter->SetInput(pd);
     369#endif
     370
    341371                }
    342372            }
    … …  
    354384                imageData->GetDimensions(dims);
    355385                TRACE("Image data dimensions: %d %d %d", dims[0], dims[1], dims[2]);
     386#ifdef USE_VTK6
     387                _volumeSlicer->SetInputData(ds);
     388#else
    356389                _volumeSlicer->SetInput(ds);
     390#endif
    357391                _volumeSlicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, (dims[2]-1)/2, (dims[2]-1)/2);
    358392                _volumeSlicer->SetSampleRate(1, 1, 1);
    … …  
    364398                // Sample a plane within the grid bounding box
    365399                vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
     400#ifdef USE_VTK6
     401                cutter->SetInputData(ds);
     402#else
    366403                cutter->SetInput(ds);
     404#endif
    367405                if (_cutPlane == NULL) {
    368406                    _cutPlane = vtkSmartPointer<vtkPlane>::New();
    … …  
    376414            } else {
    377415                // 2D data
     416#ifdef USE_VTK6
     417                gf->SetInputData(ds);
     418#else
    378419                gf->SetInput(ds);
     420#endif
    379421            }
    380422            vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
    … …  
    424466    }
    425467
     468    //setAspect(1.0);
     469
    426470    _dsActor->SetMapper(_dsMapper);
    427471
    428472    _dsMapper->Update();
    429473    _contourMapper->Update();
     474}
     475
     476void HeightMap::setAspect(double aspect)
     477{
     478    double bounds[6];
     479    vtkDataSet *ds = _dataSet->getVtkDataSet();
     480    ds->GetBounds(bounds);
     481    double size[3];
     482    size[0] = bounds[1] - bounds[0];
     483    size[1] = bounds[3] - bounds[2];
     484    size[2] = bounds[5] - bounds[4];
     485    double scale[3];
     486    scale[0] = scale[1] = scale[2] = 1.;
     487
     488    if (aspect == 1.0) {
     489        // Square
     490        switch (_sliceAxis) {
     491        case X_AXIS: {
     492            if (size[1] > size[2] && size[2] > 1.0e-6) {
     493                scale[2] = size[1] / size[2];
     494            } else if (size[2] > size[1] && size[1] > 1.0e-6) {
     495                scale[1] = size[2] / size[1];
     496            }
     497        }
     498            break;
     499        case Y_AXIS: {
     500            if (size[0] > size[2] && size[2] > 1.0e-6) {
     501                scale[2] = size[0] / size[2];
     502            } else if (size[2] > size[0] && size[0] > 1.0e-6) {
     503                scale[0] = size[2] / size[0];
     504            }
     505        }
     506            break;
     507        case Z_AXIS: {
     508            if (size[0] > size[1] && size[1] > 1.0e-6) {
     509                scale[1] = size[0] / size[1];
     510            } else if (size[1] > size[0] && size[0] > 1.0e-6) {
     511                scale[0] = size[1] / size[0];
     512            }
     513        }
     514            break;
     515        }
     516    } else if (aspect != 0.0) {
     517        switch (_sliceAxis) {
     518        case X_AXIS: {
     519            if (aspect > 1.0) {
     520                if (size[2] > size[1]) {
     521                    scale[1] = (size[2] / aspect) / size[1];
     522                } else {
     523                    scale[2] = (size[1] * aspect) / size[2];
     524                }
     525            } else {
     526                if (size[1] > size[2]) {
     527                    scale[2] = (size[1] * aspect) / size[2];
     528                } else {
     529                    scale[1] = (size[2] / aspect) / size[1];
     530                }
     531            }
     532        }
     533            break;
     534        case Y_AXIS: {
     535            if (aspect > 1.0) {
     536                if (size[0] > size[2]) {
     537                    scale[2] = (size[0] / aspect) / size[2];
     538                } else {
     539                    scale[0] = (size[2] * aspect) / size[0];
     540                }
     541            } else {
     542                if (size[2] > size[0]) {
     543                    scale[0] = (size[2] * aspect) / size[0];
     544                } else {
     545                    scale[2] = (size[0] / aspect) / size[2];
     546                }
     547            }
     548        }
     549            break;
     550        case Z_AXIS: {
     551            if (aspect > 1.0) {
     552                if (size[0] > size[1]) {
     553                    scale[1] = (size[0] / aspect) / size[1];
     554                } else {
     555                    scale[0] = (size[1] * aspect) / size[0];
     556                }
     557            } else {
     558                if (size[1] > size[0]) {
     559                    scale[0] = (size[1] * aspect) / size[0];
     560                } else {
     561                    scale[1] = (size[0] / aspect) / size[1];
     562                }
     563            }
     564        }
     565            break;
     566        }
     567    }
     568
     569    TRACE("obj %g,%g,%g", size[0], size[1], size[2]);
     570    TRACE("Setting scale to %g,%g,%g", scale[0], scale[1], scale[2]);
     571    setScale(scale);
    430572}
    431573
    … …  
    483625        _warp->UseNormalOn();
    484626        _warp->SetScaleFactor(_warpScale * _dataScale);
     627#ifdef USE_VTK6
     628        _warp->SetInputData(pdInput);
     629#else
    485630        _warp->SetInput(pdInput);
     631#endif
    486632        return _warp->GetOutputPort();
    487633    }

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

    r3177 r3189  
    6060
    6161    virtual void setClippingPlanes(vtkPlaneCollection *planes);
     62
     63    virtual void setAspect(double aspect);
    6264
    6365    void selectVolumeSlice(Axis axis, double ratio);

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

    r3177 r3189  
    88#include <cassert>
    99
     10#include <vtkVersion.h>
     11#if (VTK_MAJOR_VERSION >= 6)
     12#define USE_VTK6
     13#endif
    1014#include <vtkActor.h>
    1115#include <vtkProperty.h>
    … …  
    7478             cellToPtData =
    7579                 vtkSmartPointer<vtkCellDataToPointData>::New();
     80#ifdef USE_VTK6
     81             cellToPtData->SetInputData(ds);
     82#else
    7683             cellToPtData->SetInput(ds);
     84#endif
    7785             //cellToPtData->PassCellDataOn();
    7886             cellToPtData->Update();
    … …  
    96104            imageData->GetDimensions(dims);
    97105            TRACE("Image data dimensions: %d %d %d", dims[0], dims[1], dims[2]);
     106#ifdef USE_VTK6
     107            _volumeSlicer->SetInputData(ds);
     108#else
    98109            _volumeSlicer->SetInput(ds);
     110#endif
    99111            _volumeSlicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, (dims[2]-1)/2, (dims[2]-1)/2);
    100112            _volumeSlicer->SetSampleRate(1, 1, 1);
    … …  
    102114        } else {
    103115            // 2D image/volume/uniform grid
     116#ifdef USE_VTK6
     117            _lic->SetInputData(ds);
     118#else
    104119            _lic->SetInput(ds);
     120#endif
    105121        }
    106122        if (_mapper == NULL) {
    … …  
    150166                                     bounds[4] + (bounds[5]-bounds[4])/2.);
    151167            }
     168#ifdef USE_VTK6
     169            cutter->SetInputData(ds);
     170#else
    152171            cutter->SetInput(ds);
     172#endif
    153173            cutter->SetCutFunction(_cutPlane);
    154174            _probeFilter->SetSourceConnection(cutter->GetOutputPort());
    155175        } else {
     176#ifdef USE_VTK6
     177            _probeFilter->SetSourceData(ds);
     178#else
    156179            _probeFilter->SetSource(ds);
     180#endif
    157181        }
    158182
    … …  
    197221        imageData->SetOrigin(origin);
    198222        imageData->SetSpacing(spacing);
     223#ifdef USE_VTK6
     224        _probeFilter->SetInputData(imageData);
     225#else
    199226        _probeFilter->SetInput(imageData);
     227#endif
    200228        _lic->SetInputConnection(_probeFilter->GetOutputPort());
    201229
    … …  
    228256         }
    229257        ppdmapper->SetPainter(_painter);
     258#ifdef USE_VTK6
     259        ppdmapper->SetInputData(pd);
     260#else
    230261        ppdmapper->SetInput(pd);
     262#endif
    231263    }
    232264

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

    r3177 r3189  
    1010#include <cassert>
    1111
     12#include <vtkVersion.h>
     13#if (VTK_MAJOR_VERSION >= 6)
     14#define USE_VTK6
     15#endif
    1216#include <vtkDataSet.h>
    1317#include <vtkCellArray.h>
    … …  
    206210            if (_tuber == NULL)
    207211                _tuber = vtkSmartPointer<vtkTubeFilter>::New();
     212#ifdef USE_VTK6
     213            _tuber->SetInputData(pd);
     214#else
    208215            _tuber->SetInput(pd);
     216#endif
    209217            _tuber->SetNumberOfSides(12);
    210218            _tuber->CappingOff();
    … …  
    234242
    235243            _bondMapper->SetSourceConnection(_cylinderTrans->GetOutputPort());
    236             _bondMapper->SetInputConnection(_bondPD->GetProducerPort());
     244#ifdef USE_VTK6
     245            _bondMapper->SetInputData(_bondPD);
     246#else
     247            _bondMapper->SetInput(_bondPD);
     248#endif
    237249            _bondMapper->SetOrientationArray("bond_orientations");
    238250            _bondMapper->SetOrientationModeToDirection();
    … …  
    248260        if (pd->GetNumberOfVerts() > 0) {
    249261            vtkSmartPointer<vtkPointSetToLabelHierarchy> hier = vtkSmartPointer<vtkPointSetToLabelHierarchy>::New();
     262#ifdef USE_VTK6
     263            hier->SetInputData(pd);
     264#else
    250265            hier->SetInput(pd);
     266#endif
    251267            hier->SetLabelArrayName("labels");
    252268            hier->GetTextProperty()->SetColor(0, 0, 0);
    … …  
    263279                _glypher = vtkSmartPointer<vtkGlyph3D>::New();
    264280            _glypher->SetSourceConnection(sphereSource->GetOutputPort());
     281#ifdef USE_VTK6
     282            _glypher->SetInputData(pd);
     283#else
    265284            _glypher->SetInput(pd);
     285#endif
    266286            if (ds->GetPointData() != NULL &&
    267287                ds->GetPointData()->GetVectors() != NULL) {
    … …  
    277297#else
    278298            _atomMapper->SetSourceConnection(sphereSource->GetOutputPort());
    279             _atomMapper->SetInputConnection(pd->GetProducerPort());
     299#ifdef USE_VTK6
     300            _atomMapper->SetInputData(pd);
     301#else
     302            _atomMapper->SetInput(pd);
     303#endif
    280304            if (ds->GetPointData() != NULL &&
    281305                ds->GetPointData()->GetVectors() != NULL) {

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

    r3177 r3189  
    88#include <cassert>
    99
     10#include <vtkVersion.h>
     11#if (VTK_MAJOR_VERSION >= 6)
     12#define USE_VTK6
     13#endif
    1014#include <vtkDataSet.h>
    1115#include <vtkPolyData.h>
    … …  
    8084            if (_dataSet->numDimensions() < 2 || pd->GetNumberOfPoints() < 3) {
    8185                // 0D or 1D or not enough points to mesh
     86#ifdef USE_VTK6
     87                _pdMapper->SetInputData(pd);
     88#else
    8289                _pdMapper->SetInput(pd);
     90#endif
    8391            } else if (_dataSet->is2D(&plane, &offset)) {
    8492                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    … …  
    103111                    mesher->SetTransform(trans);
    104112                }
     113#ifdef USE_VTK6
     114                mesher->SetInputData(pd);
     115#else
    105116                mesher->SetInput(pd);
     117#endif
    106118                mesher->ReleaseDataFlagOn();
    107119                mesher->Update();
    … …  
    114126                if (outpd->GetNumberOfPolys() == 0) {
    115127                    WARN("Delaunay2D mesher failed");
     128#ifdef USE_VTK6
     129                    _pdMapper->SetInputData(pd);
     130#else
    116131                    _pdMapper->SetInput(pd);
     132#endif
    117133                } else {
    118134                    _pdMapper->SetInputConnection(mesher->GetOutputPort());
    … …  
    120136            } else {
    121137                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     138#ifdef USE_VTK6
     139                mesher->SetInputData(pd);
     140#else
    122141                mesher->SetInput(pd);
     142#endif
    123143                mesher->ReleaseDataFlagOn();
    124144                mesher->Update();
    … …  
    128148                if (grid->GetNumberOfCells() == 0) {
    129149                    WARN("Delaunay3D mesher failed");
     150#ifdef USE_VTK6
     151                    _pdMapper->SetInputData(pd);
     152#else
    130153                    _pdMapper->SetInput(pd);
     154#endif
    131155                } else {
    132156                    // Delaunay3D returns an UnstructuredGrid, so feed it
    … …  
    142166        } else {
    143167            // DataSet is a vtkPolyData with lines and/or polygons
     168#ifdef USE_VTK6
     169            _pdMapper->SetInputData(pd);
     170#else
    144171            _pdMapper->SetInput(pd);
     172#endif
    145173        }
    146174    } else {
    … …  
    149177        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    150178        gf->UseStripsOn();
     179#ifdef USE_VTK6
     180        gf->SetInputData(ds);
     181#else
    151182        gf->SetInput(ds);
     183#endif
    152184        gf->ReleaseDataFlagOn();
    153185        _pdMapper->SetInputConnection(gf->GetOutputPort());

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

    r3177 r3189  
    1010#include <cstring>
    1111
     12#include <vtkVersion.h>
     13#if (VTK_MAJOR_VERSION >= 6)
     14#define USE_VTK6
     15#endif
    1216#include <vtkDataSet.h>
    1317#include <vtkPointData.h>
    … …  
    136140                    mesher->SetTransform(trans);
    137141                }
     142#ifdef USE_VTK6
     143                mesher->SetInputData(pd);
     144#else
    138145                mesher->SetInput(pd);
     146#endif
    139147                _dsMapper->SetInputConnection(mesher->GetOutputPort());
    140148#else
    141149                vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    142150                vtkSmartPointer<vtkExtractVOI> slicer = vtkSmartPointer<vtkExtractVOI>::New();
     151#ifdef USE_VTK6
     152                splatter->SetInputData(pd);
     153#else
    143154                splatter->SetInput(pd);
     155#endif
    144156                int dims[3];
    145157                splatter->GetSampleDimensions(dims);
    … …  
    172184            } else {
    173185                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     186#ifdef USE_VTK6
     187                mesher->SetInputData(pd);
     188#else
    174189                mesher->SetInput(pd);
     190#endif
    175191                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    176192                gf->SetInputConnection(mesher->GetOutputPort());
    … …  
    179195        } else {
    180196            // DataSet is a vtkPolyData with lines and/or polygons
     197#ifdef USE_VTK6
     198            _dsMapper->SetInputData(ds);
     199#else
    181200            _dsMapper->SetInput(ds);
     201#endif
    182202        }
    183203    } else {
    … …  
    185205        // DataSet is NOT a vtkPolyData
    186206        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     207#ifdef USE_VTK6
     208        gf->SetInputData(ds);
     209#else
    187210        gf->SetInput(ds);
     211#endif
    188212        _dsMapper->SetInputConnection(gf->GetOutputPort());
    189213    }

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

    r3177 r3189  
    1212#include <cstring>
    1313
     14#include <vtkVersion.h>
     15#if (VTK_MAJOR_VERSION >= 6)
     16#define USE_VTK6
     17#endif
    1418#include <vtkMath.h>
    1519#include <vtkActor.h>
    … …  
    484488            cellToPtData =
    485489                vtkSmartPointer<vtkCellDataToPointData>::New();
     490#ifdef USE_VTK6
     491            cellToPtData->SetInputData(ds);
     492#else
    486493            cellToPtData->SetInput(ds);
     494#endif
    487495            //cellToPtData->PassCellDataOn();
    488496            cellToPtData->Update();
    … …  
    495503    }
    496504
     505#ifdef USE_VTK6
     506    _streamTracer->SetInputData(ds);
     507#else
    497508    _streamTracer->SetInput(ds);
     509#endif
    498510    _streamTracer->SetMaximumPropagation(xLen + yLen + zLen);
    499511    _streamTracer->SetIntegratorTypeToRungeKutta45();
    … …  
    542554    }
    543555
    544 #if defined(DEBUG) && defined(WANT_TRACE)
     556#if 1 && defined(WANT_TRACE)
    545557    _streamTracer->Update();
    546558    vtkPolyData *pd = _streamTracer->GetOutput();
    547559    TRACE("Verts: %d Lines: %d Polys: %d Strips: %d",
    548                   pd->GetNumberOfVerts(),
    549                   pd->GetNumberOfLines(),
    550                   pd->GetNumberOfPolys(),
    551                   pd->GetNumberOfStrips());
     560          pd->GetNumberOfVerts(),
     561          pd->GetNumberOfLines(),
     562          pd->GetNumberOfPolys(),
     563          pd->GetNumberOfStrips());
     564    vtkCellArray *arr = pd->GetLines();
     565    arr->InitTraversal();
     566    vtkIdType npts, *pts;
     567    arr->GetNextCell(npts, pts);
     568    for (int i = 0; i < npts; i++) {
     569        TRACE("Pt: %d", pts[i]);
     570    }
    552571#endif
    553572
    … …  
    630649        }
    631650
     651#ifdef USE_VTK6
     652        _streamTracer->SetSourceData(seed);
     653#else
    632654        _streamTracer->SetSource(seed);
     655
    633656        if (oldSeed != NULL) {
    634657            oldSeed->SetPipelineInformation(NULL);
    635658        }
    636 
     659#endif
    637660        if (vtkPolyData::SafeDownCast(seed) != NULL) {
     661#ifdef USE_VTK6
     662            _seedMapper->SetInputData(vtkPolyData::SafeDownCast(seed));
     663#else
    638664            _seedMapper->SetInput(vtkPolyData::SafeDownCast(seed));
     665#endif
    639666        } else {
    640667            vtkSmartPointer<vtkVertexGlyphFilter> vertFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
     668#ifdef USE_VTK6
     669            vertFilter->SetInputData(seed);
     670#else
    641671            vertFilter->SetInput(seed);
     672#endif
    642673            _seedMapper->SetInputConnection(vertFilter->GetOutputPort());
    643674        }
    … …  
    661692        _seedMesh = ds;
    662693        _seedType = FILLED_MESH;
     694#ifdef DEBUG
     695        DataSet::print(ds);
     696#endif
    663697    } else {
    664698        _seedMesh = NULL;
    … …  
    692726        }
    693727
     728#ifdef USE_VTK6
     729        _streamTracer->SetSourceData(seed);
     730        _seedMapper->SetInputData(seed);
     731#else
    694732        _streamTracer->SetSource(seed);
     733
    695734        if (oldSeed != NULL) {
    696735            oldSeed->SetPipelineInformation(NULL);
    697736        }
    698 
    699737        _seedMapper->SetInput(seed);
     738#endif
    700739    }
    701740}
    … …  
    746785            oldSeed = _streamTracer->GetSource();
    747786        }
    748 
     787#ifdef USE_VTK6
     788        _streamTracer->SetSourceData(seed);
     789        _seedMapper->SetInputData(seed);
     790#else
    749791        _streamTracer->SetSource(seed);
    750792        if (oldSeed != NULL) {
    … …  
    753795
    754796        _seedMapper->SetInput(seed);
     797#endif
    755798    }
    756799}
    … …  
    819862        for (int j = 0; j < numPoints; j++) {
    820863            // Get random sweep angle and radius
     864#ifdef USE_VTK6
     865            double angle = getRandomNum(0, 2.0 * vtkMath::Pi());
     866#else
    821867            double angle = getRandomNum(0, 2.0 * vtkMath::DoublePi());
     868#endif
    822869            // Need sqrt to get uniform distribution
    823870            double r = sqrt(getRandomNum(minSquared, 1)) * radius;
    … …  
    840887            oldSeed = _streamTracer->GetSource();
    841888        }
    842 
     889#ifdef USE_VTK6
     890        _streamTracer->SetSourceData(seed);
     891        _seedMapper->SetInputData(seed);
     892#else
    843893        _streamTracer->SetSource(seed);
    844894        if (oldSeed != NULL) {
    … …  
    847897
    848898        _seedMapper->SetInput(seed);
     899#endif
    849900    }
    850901}
    … …  
    908959        }
    909960
     961#ifndef USE_VTK6
    910962        if (oldSeed != NULL) {
    911963            oldSeed->SetPipelineInformation(NULL);
    912964        }
     965#endif
    913966    }
    914967}
    … …  
    9771030
    9781031        double verts[numSides][3];
     1032#ifdef USE_VTK6
     1033        double sliceTheta = 2.0 * vtkMath::Pi() / (double)numSides;
     1034#else
    9791035        double sliceTheta = 2.0 * vtkMath::DoublePi() / (double)numSides;
     1036#endif
    9801037        angle = vtkMath::RadiansFromDegrees(angle);
    9811038        for (int j = 0; j < numSides; j++) {
    … …  
    10211078        }
    10221079
     1080#ifdef USE_VTK6
     1081        _streamTracer->SetSourceData(seed);
     1082        _seedMapper->SetInputData(seed);
     1083#else
    10231084        _streamTracer->SetSource(seed);
    10241085        if (oldSeed != NULL) {
    … …  
    10271088
    10281089        _seedMapper->SetInput(seed);
     1090#endif
    10291091    }
    10301092}

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

    r3177 r3189  
    88#include <cassert>
    99
     10#include <vtkVersion.h>
     11#if (VTK_MAJOR_VERSION >= 6)
     12#define USE_VTK6
     13#endif
    1014#include <vtkDataSet.h>
    1115#include <vtkPointData.h>
    … …  
    109113        _volumeMapper = vtkSmartPointer<vtkVolumeTextureMapper3D>::New();
    110114#endif
     115#ifdef USE_VTK6
     116#ifdef USE_GPU_RAYCAST_MAPPER
     117        vtkGPUVolumeRayCastMapper::SafeDownCast(_volumeMapper)->SetInputData(ds);
     118#else
     119        vtkVolumeTextureMapper3D::SafeDownCast(_volumeMapper)->SetInputData(ds);
     120#endif
     121#else
    111122        _volumeMapper->SetInput(ds);
     123#endif
    112124        vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
    113125    } else if (vtkUnstructuredGrid::SafeDownCast(ds) != NULL) {
    … …  
    120132        if (ugrid->GetCellType(0) == VTK_TETRA &&
    121133            ugrid->IsHomogeneous()) {
     134#ifdef USE_VTK6
     135            vtkProjectedTetrahedraMapper::SafeDownCast(_volumeMapper)->SetInputData(ds);
     136#else
    122137            _volumeMapper->SetInput(ds);
     138#endif
    123139        } else {
    124140            // Decompose to tetrahedra
    125141            vtkSmartPointer<vtkDataSetTriangleFilter> filter =
    126142                vtkSmartPointer<vtkDataSetTriangleFilter>::New();
     143#ifdef USE_VTK6
     144            filter->SetInputData(ugrid);
     145#else
    127146            filter->SetInput(ugrid);
     147#endif
    128148            filter->TetrahedraOnlyOn();
    129149            _volumeMapper->SetInputConnection(filter->GetOutputPort());
    … …  
    138158        // DataSet is a 3D point cloud
    139159        vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
     160#ifdef USE_VTK6
     161        splatter->SetInputData(ds);
     162#else
    140163        splatter->SetInput(ds);
     164#endif
    141165        int dims[3];
    142166        dims[0] = dims[1] = dims[2] = 64;

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

    r3177 r3189  
    1111#include <cmath>
    1212
     13#include <vtkVersion.h>
     14#if (VTK_MAJOR_VERSION >= 6)
     15#define USE_VTK6
     16#endif
    1317#include <vtkCharArray.h>
    1418#include <vtkDataSetReader.h>
    … …  
    6872        if (_outlineFilter == NULL) {
    6973            _outlineFilter = vtkSmartPointer<vtkOutlineFilter>::New();
     74#ifdef USE_VTK6
     75            _outlineFilter->SetInputData(_dataSet);
     76#else
    7077            _outlineFilter->SetInput(_dataSet);
     78#endif
    7179        }
    7280        if (_outlineMapper == NULL) {
    … …  
    149157
    150158    writer->SetFileName(filename);
     159#ifdef USE_VTK6
     160    writer->SetInputData(_dataSet);
     161#else
    151162    writer->SetInput(_dataSet);
     163#endif
    152164    writer->Write();
    153165}
    … …  
    347359
    348360    _dataSet = reader->GetOutput();
     361#ifndef USE_VTK6
    349362    _dataSet->SetPipelineInformation(NULL);
    350 
     363#endif
    351364    if (_dataSet->GetPointData() != NULL &&
    352365        _dataSet->GetPointData()->GetScalars() != NULL &&
    … …  
    372385{
    373386    _dataSet = ds;
     387#ifndef USE_VTK6
    374388    _dataSet->SetPipelineInformation(NULL);
     389#endif
    375390
    376391    if (_dataSet->GetPointData() != NULL &&

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

    r3177 r3189  
    99#include <typeinfo>
    1010
     11#include <vtkVersion.h>
     12#if (VTK_MAJOR_VERSION >= 6)
     13#define USE_VTK6
     14#endif
    1115#include <vtkSmartPointer.h>
    1216#include <vtkDataSet.h>
    … …  
    21832187        return false;
    21842188    }
     2189#ifndef USE_VTK6
    21852190    dataSet->SetPipelineInformation(NULL);
    2186 
     2191#endif
    21872192    StreamlinesHashmap::iterator itr;
    21882193
    … …  
    22352240        return false;
    22362241    }
     2242#ifndef USE_VTK6
    22372243    dataSet->SetPipelineInformation(NULL);
    2238 
     2244#endif
    22392245    StreamlinesHashmap::iterator itr;
    22402246

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

    r3177 r3189  
    1010#include <cstring>
    1111
     12#include <vtkVersion.h>
     13#if (VTK_MAJOR_VERSION >= 6)
     14#define USE_VTK6
     15#endif
    1216#include <vtkDataSet.h>
    1317#include <vtkPointData.h>
    … …  
    5761
    5862void Warp::setDataSet(DataSet *dataSet,
    59                       Renderer *renderer)
     63                      Renderer *renderer)
    6064{
    6165    if (_dataSet != dataSet) {
    … …  
    99103
    100104    if (_warp == NULL) {
    101         _warp = vtkSmartPointer<vtkWarpVector>::New();
     105        _warp = vtkSmartPointer<vtkWarpVector>::New();
    102106    }
    103107
    … …  
    112116    vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
    113117    if (ds->GetPointData() == NULL ||
    114         ds->GetPointData()->GetVectors() == NULL) {
    115         TRACE("No vector point data in dataset %s", _dataSet->getName().c_str());
    116         if (ds->GetCellData() != NULL &&
    117             ds->GetCellData()->GetVectors() != NULL) {
    118             cellToPtData =
    119                 vtkSmartPointer<vtkCellDataToPointData>::New();
    120             cellToPtData->SetInput(ds);
    121             //cellToPtData->PassCellDataOn();
    122             cellToPtData->Update();
    123             ds = cellToPtData->GetOutput();
    124         } else {
    125             ERROR("No vector data in dataset %s", _dataSet->getName().c_str());
    126             return;
    127         }
     118        ds->GetPointData()->GetVectors() == NULL) {
     119        TRACE("No vector point data in dataset %s", _dataSet->getName().c_str());
     120        if (ds->GetCellData() != NULL &&
     121            ds->GetCellData()->GetVectors() != NULL) {
     122            cellToPtData =
     123                vtkSmartPointer<vtkCellDataToPointData>::New();
     124#ifdef USE_VTK6
     125            cellToPtData->SetInputData(ds);
     126#else
     127            cellToPtData->SetInput(ds);
     128#endif
     129            //cellToPtData->PassCellDataOn();
     130            cellToPtData->Update();
     131            ds = cellToPtData->GetOutput();
     132        } else {
     133            ERROR("No vector data in dataset %s", _dataSet->getName().c_str());
     134            return;
     135        }
    128136    }
    129137
    … …  
    160168                    mesher->SetTransform(trans);
    161169                }
     170#ifdef USE_VTK6
     171                mesher->SetInputData(pd);
     172#else
    162173                mesher->SetInput(pd);
    163                 vtkAlgorithmOutput *warpOutput = initWarp(mesher->GetOutputPort());
     174#endif
     175                vtkAlgorithmOutput *warpOutput = initWarp(mesher->GetOutputPort());
    164176                _dsMapper->SetInputConnection(warpOutput);
    165177#else
    166178                vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    167179                vtkSmartPointer<vtkExtractVOI> slicer = vtkSmartPointer<vtkExtractVOI>::New();
     180#ifdef USE_VTK6
     181                splatter->SetInputData(pd);
     182#else
    168183                splatter->SetInput(pd);
     184#endif
    169185                int dims[3];
    170186                splatter->GetSampleDimensions(dims);
    … …  
    193209                gf->UseStripsOn();
    194210                gf->SetInputConnection(slicer->GetOutputPort());
    195                 vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
     211                vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
    196212                _dsMapper->SetInputConnection(warpOutput);
    197213#endif
    198214            } else {
    199                 // Data Set is a 3D point cloud
     215                // Data Set is a 3D point cloud
    200216                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     217#ifdef USE_VTK6
     218                mesher->SetInputData(pd);
     219#else
    201220                mesher->SetInput(pd);
     221#endif
    202222                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    203                 gf->SetInputConnection(mesher->GetOutputPort());
    204                 vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
     223                gf->SetInputConnection(mesher->GetOutputPort());
     224                vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
    205225                _dsMapper->SetInputConnection(warpOutput);
    206226             }
    207227        } else {
    208228            // DataSet is a vtkPolyData with lines and/or polygons
    209             vtkAlgorithmOutput *warpOutput = initWarp(pd);
    210             _dsMapper->SetInput(ds);
    211             if (warpOutput != NULL) {
    212                 _dsMapper->SetInputConnection(warpOutput);
    213             } else {
    214                 _dsMapper->SetInput(pd);
    215             }
     229            vtkAlgorithmOutput *warpOutput = initWarp(pd);
     230            if (warpOutput != NULL) {
     231                _dsMapper->SetInputConnection(warpOutput);
     232            } else {
     233#ifdef USE_VTK6
     234                _dsMapper->SetInputData(pd);
     235#else
     236                _dsMapper->SetInput(pd);
     237#endif
     238            }
    216239        }
    217240    } else {
    … …  
    219242        // DataSet is NOT a vtkPolyData
    220243        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     244#ifdef USE_VTK6
     245        gf->SetInputData(ds);
     246#else
    221247        gf->SetInput(ds);
    222         vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
     248#endif
     249        vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
    223250        _dsMapper->SetInputConnection(warpOutput);
    224251    }
    … …  
    266293            _warp = vtkSmartPointer<vtkWarpVector>::New();
    267294        _warp->SetScaleFactor(_warpScale);
     295#ifdef USE_VTK6
     296        _warp->SetInputData(ds);
     297#else
    268298        _warp->SetInput(ds);
     299#endif
    269300        return _warp->GetOutputPort();
    270301    }
    … …  
    375406
    376407void Warp::setColorMode(ColorMode mode,
    377                         const char *name, double range[2])
     408                        const char *name, double range[2])
    378409{
    379410    if (_dataSet == NULL)
    … …  
    390421
    391422void Warp::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
    392                         const char *name, double range[2])
     423                        const char *name, double range[2])
    393424{
    394425    _colorMode = mode;
Note: See TracChangeset for help on using the changeset viewer.