InterpolateMeshOnGrid

VTKExamples/Cxx/PolyData/InterpolateMeshOnGrid


Description

This example resamples a mesh on a grid of points.

Code

InterpolateMeshOnGrid.cxx

#include <vtkVersion.h>
#include <vtkProperty.h>
#include <vtkDataSetMapper.h>
#include <vtkSmartPointer.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkTriangle.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkLine.h>
#include <vtkImageData.h>
#include <vtkProbeFilter.h>
#include <vtkDelaunay2D.h>
#include <vtkXMLPolyDataWriter.h>
#include <vtkDoubleArray.h>
#include <vtkMath.h>
#include <vtkCellLocator.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkFloatArray.h>
#include <vtkWarpScalar.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkInteractorStyleTrackballCamera.h>

int main(int, char *[])
{
  // Create a random set of 100 points in the xy-plane in (0,10)x(0,10).
  // If you had instead started with a set of (x,y,z) points, you must copy
  // the zvalues into a FloatArray and set it as the data set's scalars,
  // and then set the z-coordinates to zero
  vtkSmartPointer<vtkPoints> randomPoints =
    vtkSmartPointer<vtkPoints>::New();

  vtkSmartPointer<vtkFloatArray> zvalues =
    vtkSmartPointer<vtkFloatArray>::New();
  zvalues->SetName("ZValues");

  unsigned int gridSize = 10;
  float maxHeight = 5;
  for ( unsigned int i = 0; i < 100; ++i )
  {
    double x = vtkMath::Random(0, gridSize);
    double y = vtkMath::Random(0, gridSize);
    double z = vtkMath::Random(0, maxHeight);

    //randomPoints->InsertNextPoint ( x, y, z);
    randomPoints->InsertNextPoint ( x, y, 0);
    zvalues->InsertNextValue(z);
  }

  // Add the grid points to a polydata object
  vtkSmartPointer<vtkPolyData> randomPolyData =
    vtkSmartPointer<vtkPolyData>::New();
  randomPolyData->SetPoints ( randomPoints );
  randomPolyData->GetPointData()->SetScalars(zvalues);

  // Triangulate the grid points. If you do not have a mesh (points
  // only), the output will not be interpolated!
  vtkSmartPointer<vtkDelaunay2D> randomDelaunay =
    vtkSmartPointer<vtkDelaunay2D>::New();
#if VTK_MAJOR_VERSION <= 5
  randomDelaunay->SetInput ( randomPolyData );
#else
  randomDelaunay->SetInputData ( randomPolyData );
#endif
  randomDelaunay->Update();

  // Create a grid of points to interpolate over
  vtkSmartPointer<vtkPoints> gridPoints =
    vtkSmartPointer<vtkPoints>::New();
  for ( unsigned int x = 0; x < gridSize; x++ )
  {
    for ( unsigned int y = 0; y < gridSize; y++ )
    {
      gridPoints->InsertNextPoint ( x, y, 0);
    }
  }

  // Create a dataset from the grid points
  vtkSmartPointer<vtkPolyData> gridPolyData =
    vtkSmartPointer<vtkPolyData>::New();
  gridPolyData->SetPoints(gridPoints);

  // Perform the interpolation
  vtkSmartPointer<vtkProbeFilter> probeFilter =
    vtkSmartPointer<vtkProbeFilter>::New();
  probeFilter->SetSourceConnection(randomDelaunay->GetOutputPort());
#if VTK_MAJOR_VERSION <= 5
  probeFilter->SetInput(gridPolyData); //
                                      // Interpolate 'Source' at these points
#else
  probeFilter->SetInputData(gridPolyData); //
                                           // Interpolate 'Source' at these points
#endif
  probeFilter->Update();

  // Map the output zvalues to the z-coordinates of the data so that
  // we get a surface, rather than a flat grid with interpolated
  // scalars.
  vtkSmartPointer<vtkWarpScalar> gridWarpScalar =
    vtkSmartPointer<vtkWarpScalar>::New();
  gridWarpScalar->SetInputConnection(probeFilter->GetOutputPort());
  gridWarpScalar->Update();

  //////// Setup outputs ////////
  // Output random points
  // Map the output zvalues to the z-coordinates of the data
  vtkSmartPointer<vtkWarpScalar> randomWarpScalar =
    vtkSmartPointer<vtkWarpScalar>::New();
  randomWarpScalar->SetInputConnection(randomDelaunay->GetOutputPort());
  randomWarpScalar->Update();

  vtkSmartPointer<vtkXMLPolyDataWriter> randomWriter =
    vtkSmartPointer<vtkXMLPolyDataWriter>::New();
  randomWriter->SetFileName ( "randomSurface.vtp" );
  randomWriter->SetInputConnection(randomWarpScalar->GetOutputPort());
  randomWriter->Write();

  // Mesh the output grid points
  vtkSmartPointer<vtkDelaunay2D> gridDelaunay =
    vtkSmartPointer<vtkDelaunay2D>::New();
  gridDelaunay->SetInputConnection ( gridWarpScalar->GetOutputPort() );

  vtkSmartPointer<vtkXMLPolyDataWriter> gridWriter =
    vtkSmartPointer<vtkXMLPolyDataWriter>::New();
  gridWriter->SetFileName ( "gridSurface.vtp" );
  gridWriter->SetInputConnection ( gridDelaunay->GetOutputPort() );
  gridWriter->Write();

  ////////// Setup visualization ////////
  vtkSmartPointer<vtkDataSetMapper> randomMapper =
    vtkSmartPointer<vtkDataSetMapper>::New();
  randomMapper->SetInputConnection(randomWarpScalar->GetOutputPort());
  randomMapper->ScalarVisibilityOff();

  vtkSmartPointer<vtkActor> randomActor =
    vtkSmartPointer<vtkActor>::New();
  randomActor->SetMapper(randomMapper);
  randomActor->GetProperty()->SetColor(1.0, 0.0, 0.0); //(R,G,B)
  randomActor->GetProperty()->SetPointSize(3);

  vtkSmartPointer<vtkDataSetMapper> gridMapper =
    vtkSmartPointer<vtkDataSetMapper>::New();
  gridMapper->SetInputConnection(gridDelaunay->GetOutputPort());
  gridMapper->ScalarVisibilityOff();

  vtkSmartPointer<vtkActor> gridActor =
    vtkSmartPointer<vtkActor>::New();
  gridActor->SetMapper(gridMapper);
  gridActor->GetProperty()->SetColor(0.0, 0.0, 1.0); //(R,G,B)
  gridActor->GetProperty()->SetPointSize(3);

  vtkSmartPointer<vtkRenderer> renderer =
    vtkSmartPointer<vtkRenderer>::New();
  vtkSmartPointer<vtkRenderWindow> renderWindow =
    vtkSmartPointer<vtkRenderWindow>::New();
  renderWindow->AddRenderer(renderer);
  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
    vtkSmartPointer<vtkRenderWindowInteractor>::New();
  renderWindowInteractor->SetRenderWindow(renderWindow);

  vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
    vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
  renderWindowInteractor->SetInteractorStyle( style );

  renderer->AddActor(randomActor);
  renderer->AddActor(gridActor);

  renderWindow->Render();
  renderWindowInteractor->Start();

  return EXIT_SUCCESS;
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.8)

PROJECT(InterpolateMeshOnGrid)

find_package(VTK REQUIRED)
include(${VTK_USE_FILE})

add_executable(InterpolateMeshOnGrid MACOSX_BUNDLE InterpolateMeshOnGrid.cxx )

target_link_libraries(InterpolateMeshOnGrid ${VTK_LIBRARIES})

Download and Build InterpolateMeshOnGrid

Click here to download InterpolateMeshOnGrid and its CMakeLists.txt file. Once the tarball InterpolateMeshOnGrid.tar has been downloaded and extracted,

cd InterpolateMeshOnGrid/build 

If VTK is installed:

cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

make

and run it:

./InterpolateMeshOnGrid

WINDOWS USERS

Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.