# ContoursToSurface

VTKExamples/Cxx/PolyData/ContoursToSurface

### Description

This example creates a stack of 21 circles and creates a closed surface from them.

### Code

ContoursToSurface.cxx

    #include <vtkVersion.h>
    #include <vtkActor.h>
    #include <vtkAppendPolyData.h>
    #include <vtkCellArray.h>
    #include <vtkMath.h>
    #include <vtkPolyData.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkProperty.h>
    #include <vtkRenderer.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkSmartPointer.h>
    #include <vtkTransform.h>
    #include <vtkTransformPolyDataFilter.h>
    #include <vtkVoxelContoursToSurfaceFilter.h>

    void CreateCircle(const double& z, const double& radius, const int& resolution, vtkPolyData* polyData);

    int main(int, char *[])
    {
      // Create the data: a series of discs representing the intersections of x-y planes through a unit sphere
      // centered at 0, 0, 0
      //
      int numDivisions = 20;
      int resolution = 100;
      double lastz = 0.;
      double z = 0.;
      double radius = 0.;
      double sphereRadius = 1.;
      double zmin = -0.9*sphereRadius;
      double zmax = 0.9*sphereRadius;

      // Append all the discs into one polydata
      //
      vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();

      for( int i = 0; i <= numDivisions; ++i )
      {
        lastz = z;
        double u = i / double(numDivisions);
        z = ( 1. - u )*zmin + u*zmax;
        radius = sqrt( sphereRadius*sphereRadius - z*z );
        vtkSmartPointer<vtkPolyData> circle = vtkSmartPointer<vtkPolyData>::New();
        CreateCircle( z, radius, resolution, circle );
    #if VTK_MAJOR_VERSION <= 5
        appendFilter->AddInput( circle );
    #else
        appendFilter->AddInputData( circle );
    #endif
      }

      double deltaz = z - lastz;

      if( !appendFilter->GetNumberOfInputConnections(0) )
      {
        cerr << "error, no contours!" << endl;
        return EXIT_FAILURE;
      }

      appendFilter->Update();

      // Convert to ijk coordinates for the contour to surface filter
      //
      double bounds[6];
      vtkPolyData* contours = appendFilter->GetOutput();
      contours->GetBounds( bounds );
      double origin[3]  = { bounds[0], bounds[2], bounds[4] };
      double spacing[3] = { (bounds[1] - bounds[0]) / 40,
                            (bounds[3] - bounds[2]) / 40,
                             deltaz };

      vtkSmartPointer<vtkPolyData> poly = vtkSmartPointer<vtkPolyData>::New();
      vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
      vtkPoints* contourPoints = contours->GetPoints();
      int numPoints = contourPoints->GetNumberOfPoints();
      points->SetNumberOfPoints( numPoints );
      for( int i = 0; i < numPoints; ++i )
      {
        double pt[3];
        contourPoints->GetPoint( i, pt );
        pt[0] = static_cast<int>( (pt[0] - origin[0]) / spacing[0] + 0.5 );
        pt[1] = static_cast<int>( (pt[1] - origin[1]) / spacing[1] + 0.5 );
        pt[2] = static_cast<int>( (pt[2] - origin[2]) / spacing[2] + 0.5 );
        points->SetPoint( i, pt );
      }
      poly->SetPolys( contours->GetPolys() );
      poly->SetPoints( points );

      // Create the contour to surface filter
      //
      vtkSmartPointer<vtkVoxelContoursToSurfaceFilter> contoursToSurface = vtkSmartPointer<vtkVoxelContoursToSurfaceFilter>::New();
    #if VTK_MAJOR_VERSION <= 5
      contoursToSurface->SetInput( poly );
    #else
      contoursToSurface->SetInputData( poly );
    #endif
      contoursToSurface->SetSpacing( spacing[0], spacing[1], spacing[2] );
      contoursToSurface->Update();

      // Rescale the output back into world coordinates and center it
      //
      double scaleCenter[3];
      contoursToSurface->GetOutput()->GetCenter( scaleCenter );
      double scaleBounds[6];
      contoursToSurface->GetOutput()->GetBounds( scaleBounds );
      double center[3];
      contours->GetCenter( center );

      vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
      transformFilter->SetInputConnection( contoursToSurface->GetOutputPort() );
      vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
      transformFilter->SetTransform( transform );
      transform->Translate( -scaleCenter[0], -scaleCenter[1], -scaleCenter[2] );
      transform->Scale(
        (bounds[1] - bounds[0])/(scaleBounds[1] - scaleBounds[0]),
        (bounds[3] - bounds[2])/(scaleBounds[3] - scaleBounds[2]),
        (bounds[5] - bounds[4])/(scaleBounds[5] - scaleBounds[4]) );
      transform->Translate( center[0], center[1], center[2] );

      // Visualize the contours
      //
      vtkSmartPointer<vtkPolyDataMapper> contoursMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    #if VTK_MAJOR_VERSION <= 5
      contoursMapper->SetInput( contours );
    #else
      contoursMapper->SetInputData( contours );
    #endif
      contoursMapper->ScalarVisibilityOff();

      vtkSmartPointer<vtkActor> contoursActor = vtkSmartPointer<vtkActor>::New();
      contoursActor->SetMapper( contoursMapper );
      contoursActor->GetProperty()->SetRepresentationToWireframe();
      contoursActor->GetProperty()->ShadingOff();

      // Visualize the surface
      //
      vtkSmartPointer<vtkPolyDataMapper> surfaceMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
      surfaceMapper->SetInputConnection( transformFilter->GetOutputPort() );
      surfaceMapper->ScalarVisibilityOff();
      surfaceMapper->ImmediateModeRenderingOn();

      vtkSmartPointer<vtkActor> surfaceActor = vtkSmartPointer<vtkActor>::New();
      surfaceActor->SetMapper( surfaceMapper );
      surfaceActor->GetProperty()->SetRepresentationToWireframe();
      surfaceActor->GetProperty()->ShadingOff();

      // Create two renderers side by side to show the contours and the surface separately
      //
      // Press 't' for trackball interaction
      // Press 'r' to reset the camera
      // Press 'w' for wireframe representation
      // Press 's' for surface representation
      //
      vtkSmartPointer<vtkRenderer> renderer1 = vtkSmartPointer<vtkRenderer>::New();
      renderer1->SetViewport( 0., 0., 0.5, 1. );
      renderer1->SetBackground( 0.2, 0.2, 0.8 );

      vtkSmartPointer<vtkRenderer> renderer2 = vtkSmartPointer<vtkRenderer>::New();
      renderer2->SetViewport( 0.5, 0., 1., 1. );
      renderer2->SetBackground( 0.8, 0.2, 0.2 );

      vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
      renderWindow->SetSize( 800, 400 );

      renderWindow->AddRenderer( renderer1 );
      renderWindow->AddRenderer( renderer2 );

      vtkSmartPointer<vtkRenderWindowInteractor> interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
      interactor->SetRenderWindow( renderWindow );

      renderer1->AddViewProp( surfaceActor );
      renderer2->AddViewProp( contoursActor );
      renderWindow->Render();

      interactor->Start();

      return EXIT_SUCCESS;
    }

    void CreateCircle( const double& z, const double& radius, const int& resolution, vtkPolyData* polyData )
    {
      vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
      vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();

      points->SetNumberOfPoints( resolution );
      cells->Allocate( 1, resolution );
      cells->InsertNextCell( resolution );

      for( int i = 0 ; i < resolution; ++i )
      {
        double theta = vtkMath::RadiansFromDegrees(360.*i/double(resolution));
        double x = radius*cos(theta);
        double y = radius*sin(theta);
        points->SetPoint( i, x, y, z );
        cells->InsertCellPoint( i );
      }

      polyData->Initialize();
      polyData->SetPolys( cells );
      polyData->SetPoints( points );
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 2.8)

    PROJECT(ContoursToSurface)

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

    add_executable(ContoursToSurface MACOSX_BUNDLE ContoursToSurface.cxx )

    target_link_libraries(ContoursToSurface ${VTK_LIBRARIES})

### Download and Build ContoursToSurface

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

    cd ContoursToSurface/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:

    ./ContoursToSurface

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