MarchingCases

VTKExamples/Cxx/VisualizationAlgorithms/MarchingCases

Description

This example will help you understand the Marching Cubes Algorithm. The example takes one optional argument, a case number. There are 14 Marching Cubes cases, 1-14. There are also 14 complementary cases where the inside/outside value is flipped. To see a complementray case, supply a negative case number. For example, -7 is the complementary case of 7.

Note

According to the ACM Digital Library, the Marching Cubes paper is the most cited Siggraph paper.

Code

MarchingCases.cxx

#include <vtkContourFilter.h>
#include <vtkCubeSource.h>
#include <vtkExtractEdges.h>
#include <vtkFloatArray.h>
#include <vtkGlyph3D.h>
#include <vtkIdList.h>
#include <vtkNamedColors.h>
#include <vtkPoints.h>
#include <vtkPointData.h>

#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkShrinkPolyData.h>
#include <vtkSphereSource.h>
#include <vtkThresholdPoints.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkTubeFilter.h>
#include <vtkUnstructuredGrid.h>
#include <vtkVectorText.h>

#include <map>

namespace
{
void case1 (vtkFloatArray *, vtkVectorText *, int, int);
void case2 (vtkFloatArray *, vtkVectorText *, int, int);
void case3 (vtkFloatArray *, vtkVectorText *, int, int);
void case4 (vtkFloatArray *, vtkVectorText *, int, int);
void case5 (vtkFloatArray *, vtkVectorText *, int, int);
void case6 (vtkFloatArray *, vtkVectorText *, int, int);
void case7 (vtkFloatArray *, vtkVectorText *, int, int);
void case8 (vtkFloatArray *, vtkVectorText *, int, int);
void case9 (vtkFloatArray *, vtkVectorText *, int, int);
void case10(vtkFloatArray *, vtkVectorText *, int, int);
void case11(vtkFloatArray *, vtkVectorText *, int, int);
void case12(vtkFloatArray *, vtkVectorText *, int, int);
void case13(vtkFloatArray *, vtkVectorText *, int, int);
void case14(vtkFloatArray *, vtkVectorText *, int, int);
}

int main (int argc, char *argv[])
{
  std::map<int, void (*)(vtkFloatArray*, vtkVectorText*, int, int)> cases;
  cases[1]  = &case1;
  cases[2]  = &case2;
  cases[3]  = &case3;
  cases[4]  = &case4;
  cases[5]  = &case5;
  cases[6]  = &case6;
  cases[7]  = &case7;
  cases[8]  = &case8;
  cases[9]  = &case9;
  cases[10] = &case10;
  cases[11] = &case11;
  cases[12] = &case12;
  cases[13] = &case13;
  cases[14] = &case14;

  std::vector<int> mcCases;
  int mcCase = 12;
  std::cout << "argc is " << argc << std::endl;
  if (argc > 1)
  {
    for (int i = 1; i < argc; ++i)
    {
      mcCase = atoi(argv[i]);
      if (std::abs(mcCase) < 1 || std::abs(mcCase) > 14)
      {
        std::cout << argv[0] << " bad case number " << mcCase << std::endl;
        return EXIT_FAILURE;
      }
      mcCases.push_back(mcCase);
    }
  }
  else
  {
    mcCases.push_back(12);
  }

  vtkSmartPointer<vtkNamedColors> color =
    vtkSmartPointer<vtkNamedColors>::New();

  vtkSmartPointer<vtkRenderWindow> renWin =
    vtkSmartPointer<vtkRenderWindow>::New();
  renWin->SetSize(640, 480);
  vtkSmartPointer<vtkRenderWindowInteractor> iren =
    vtkSmartPointer<vtkRenderWindowInteractor>::New();
  iren->SetRenderWindow(renWin);

  std::vector<vtkSmartPointer<vtkRenderer>> renderers;
  int gridSize = ((static_cast<int>(mcCases.size()) + 3) / 4) * 4;
  gridSize = static_cast<int>(mcCases.size()) < 4 ? 
             static_cast<int>(mcCases.size()) : gridSize;
  std::cout << "gridSize: " << gridSize << std::endl;
  for (int i = 0; i < gridSize; ++i)
  {
    // Create the Renderer
    vtkSmartPointer<vtkRenderer> renderer =
      vtkSmartPointer<vtkRenderer>::New();
    renderers.push_back(renderer);
    renWin->AddRenderer(renderer);
  }

  for (size_t i = 0; i < mcCases.size(); ++i)
  {
    // Define a Single Cube
    vtkSmartPointer<vtkFloatArray> Scalars =
      vtkSmartPointer<vtkFloatArray>::New();
    Scalars->InsertNextValue(1.0);
    Scalars->InsertNextValue(0.0);
    Scalars->InsertNextValue(0.0);
    Scalars->InsertNextValue(1.0);
    Scalars->InsertNextValue(0.0);
    Scalars->InsertNextValue(0.0);
    Scalars->InsertNextValue(0.0);
    Scalars->InsertNextValue(0.0);

    vtkSmartPointer<vtkPoints> Points =
      vtkSmartPointer<vtkPoints>::New();
    Points->InsertNextPoint(0, 0, 0);
    Points->InsertNextPoint(1, 0, 0);
    Points->InsertNextPoint(1, 1, 0);
    Points->InsertNextPoint(0, 1, 0);
    Points->InsertNextPoint(0, 0, 1);
    Points->InsertNextPoint(1, 0, 1);
    Points->InsertNextPoint(1, 1, 1);
    Points->InsertNextPoint(0, 1, 1);

    vtkSmartPointer<vtkIdList> Ids =
      vtkSmartPointer<vtkIdList>::New();
    Ids->InsertNextId(0);
    Ids->InsertNextId(1);
    Ids->InsertNextId(2);
    Ids->InsertNextId(3);
    Ids->InsertNextId(4);
    Ids->InsertNextId(5);
    Ids->InsertNextId(6);
    Ids->InsertNextId(7);

    vtkSmartPointer<vtkUnstructuredGrid> Grid =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
    Grid->Allocate(10, 10);
    Grid->InsertNextCell(12, Ids);
    Grid->SetPoints(Points);
    Grid->GetPointData()->SetScalars(Scalars);

  // Find the triangles that lie along the 0.5 contour in this cube.
    vtkSmartPointer<vtkContourFilter> Marching =
      vtkSmartPointer<vtkContourFilter>::New();
    Marching->SetInputData(Grid);
    Marching->SetValue(0, 0.5);
    Marching->Update();

  // Extract the edges of the triangles just found.
    vtkSmartPointer<vtkExtractEdges> triangleEdges =
      vtkSmartPointer<vtkExtractEdges>::New();
    triangleEdges->SetInputConnection(Marching->GetOutputPort());

  // Draw the edges as tubes instead of lines.  Also create the associated
  // mapper and actor to display the tubes.
    vtkSmartPointer<vtkTubeFilter> triangleEdgeTubes =
      vtkSmartPointer<vtkTubeFilter>::New();
    triangleEdgeTubes->SetInputConnection(triangleEdges->GetOutputPort());
    triangleEdgeTubes->SetRadius(.005);
    triangleEdgeTubes->SetNumberOfSides(6);
    triangleEdgeTubes->UseDefaultNormalOn();
    triangleEdgeTubes->SetDefaultNormal(.577, .577, .577);

    vtkSmartPointer<vtkPolyDataMapper> triangleEdgeMapper =
      vtkSmartPointer<vtkPolyDataMapper>::New();
    triangleEdgeMapper->SetInputConnection(triangleEdgeTubes->GetOutputPort());
    triangleEdgeMapper->ScalarVisibilityOff();

    vtkSmartPointer<vtkActor> triangleEdgeActor =
      vtkSmartPointer<vtkActor>::New();
    triangleEdgeActor->SetMapper(triangleEdgeMapper);
    triangleEdgeActor->GetProperty()->SetDiffuseColor(
      color->GetColor3d("lamp_black").GetData());
    triangleEdgeActor->GetProperty()->SetSpecular(.4);
    triangleEdgeActor->GetProperty()->SetSpecularPower(10);

  // Shrink the triangles we found earlier.  Create the associated mapper
  // and actor.  Set the opacity of the shrunken triangles.
    vtkSmartPointer<vtkShrinkPolyData> aShrinker =
      vtkSmartPointer<vtkShrinkPolyData>::New();
    aShrinker->SetShrinkFactor(1);
    aShrinker->SetInputConnection(Marching->GetOutputPort());

    vtkSmartPointer<vtkPolyDataMapper> aMapper =
      vtkSmartPointer<vtkPolyDataMapper>::New();
    aMapper->ScalarVisibilityOff();
    aMapper->SetInputConnection(aShrinker->GetOutputPort());

    vtkSmartPointer<vtkActor> Triangles =
      vtkSmartPointer<vtkActor>::New();
    Triangles->SetMapper(aMapper);
    Triangles->GetProperty()->SetDiffuseColor(
      color->GetColor3d("banana").GetData());
    Triangles->GetProperty()->SetOpacity(.6);

  // Draw a cube the same size and at the same position as the one
  // created previously.  Extract the edges because we only want to see
  // the outline of the cube.  Pass the edges through a vtkTubeFilter so
  // they are displayed as tubes rather than lines.
    vtkSmartPointer<vtkCubeSource> CubeModel =
      vtkSmartPointer<vtkCubeSource>::New();
    CubeModel->SetCenter(.5, .5, .5);

    vtkSmartPointer<vtkExtractEdges> Edges =
      vtkSmartPointer<vtkExtractEdges>::New();
    Edges->SetInputConnection(CubeModel->GetOutputPort());

    vtkSmartPointer<vtkTubeFilter> Tubes =
      vtkSmartPointer<vtkTubeFilter>::New();
    Tubes->SetInputConnection(Edges->GetOutputPort());
    Tubes->SetRadius(.01);
    Tubes->SetNumberOfSides(6);
    Tubes->UseDefaultNormalOn();
    Tubes->SetDefaultNormal(.577, .577, .577);
  // Create the mapper and actor to display the cube edges.
    vtkSmartPointer<vtkPolyDataMapper> TubeMapper =
      vtkSmartPointer<vtkPolyDataMapper>::New();
    TubeMapper->SetInputConnection(Tubes->GetOutputPort());
    vtkSmartPointer<vtkActor> CubeEdges =
      vtkSmartPointer<vtkActor>::New();
    CubeEdges->SetMapper(TubeMapper);
    CubeEdges->GetProperty()->SetDiffuseColor(
      color->GetColor3d("khaki").GetData());
    CubeEdges->GetProperty()->SetSpecular(.4);
    CubeEdges->GetProperty()->SetSpecularPower(10);

  // Create a sphere to use as a glyph source for vtkGlyph3D.
    vtkSmartPointer<vtkSphereSource> Sphere =
      vtkSmartPointer<vtkSphereSource>::New();
    Sphere->SetRadius(0.04);
    Sphere->SetPhiResolution(20);
    Sphere->SetThetaResolution(20);
  // Remove the part of the cube with data values below 0.5.
    vtkSmartPointer<vtkThresholdPoints> ThresholdIn =
      vtkSmartPointer<vtkThresholdPoints>::New();
    ThresholdIn->SetInputData(Grid);
    ThresholdIn->ThresholdByUpper(.5);
  // Display spheres at the vertices remaining in the cube data set after
  // it was passed through vtkThresholdPoints.
    vtkSmartPointer<vtkGlyph3D> Vertices =
      vtkSmartPointer<vtkGlyph3D>::New();
    Vertices->SetInputConnection(ThresholdIn->GetOutputPort());
    Vertices->SetSourceConnection(Sphere->GetOutputPort());
  // Create a mapper and actor to display the glyphs.
    vtkSmartPointer<vtkPolyDataMapper> SphereMapper =
      vtkSmartPointer<vtkPolyDataMapper>::New();
    SphereMapper->SetInputConnection(Vertices->GetOutputPort());
    SphereMapper->ScalarVisibilityOff();

    vtkSmartPointer<vtkActor> CubeVertices =
      vtkSmartPointer<vtkActor>::New();
    CubeVertices->SetMapper(SphereMapper);
    CubeVertices->GetProperty()->SetDiffuseColor(
      color->GetColor3d("tomato").GetData());

  // Define the text for the label
    vtkSmartPointer<vtkVectorText> caseLabel =
      vtkSmartPointer<vtkVectorText>::New();
    caseLabel->SetText("Case 1");

  // Set up a transform to move the label to a new position.
    vtkSmartPointer<vtkTransform> aLabelTransform =
      vtkSmartPointer<vtkTransform>::New();
    aLabelTransform->Identity();
    aLabelTransform->Translate(-0.2, 0, 1.25);
    aLabelTransform->Scale(.05, .05, .05);

  // Move the label to a new position.
    vtkSmartPointer<vtkTransformPolyDataFilter> labelTransform =
      vtkSmartPointer<vtkTransformPolyDataFilter>::New();
    labelTransform->SetTransform(aLabelTransform);
    labelTransform->SetInputConnection(caseLabel->GetOutputPort());

  // Create a mapper and actor to display the text.
    vtkSmartPointer<vtkPolyDataMapper> labelMapper =
      vtkSmartPointer<vtkPolyDataMapper>::New();
    labelMapper->SetInputConnection(labelTransform->GetOutputPort());

    vtkSmartPointer<vtkActor> labelActor =
      vtkSmartPointer<vtkActor>::New();
    labelActor->SetMapper(labelMapper);

  // Define the base that the cube sits on.  Create its associated mapper
  // and actor.  Set the position of the actor.
    vtkSmartPointer<vtkCubeSource> baseModel =
      vtkSmartPointer<vtkCubeSource>::New();
    baseModel->SetXLength(1.5);
    baseModel->SetYLength(.01);
    baseModel->SetZLength(1.5);

    vtkSmartPointer<vtkPolyDataMapper> baseMapper =
      vtkSmartPointer<vtkPolyDataMapper>::New();
    baseMapper->SetInputConnection(baseModel->GetOutputPort());

    vtkSmartPointer<vtkActor> base =
      vtkSmartPointer<vtkActor>::New();
    base->SetMapper(baseMapper);
    base->SetPosition(.5, -0.09, .5);

  // Set the scalar values for this case of marching cubes.
  // A negative case number will generate a complementary case
    mcCase = mcCases[i];
    if (mcCase < 0)
    {
      cases[-mcCase](Scalars, caseLabel, 0, 1);
    }
    else
    {
      cases[mcCase](Scalars, caseLabel, 1, 0);
    }
  // Force the grid to update.
    Grid->Modified();

  // Add the actors to the renderer
    renderers[i]->AddActor(triangleEdgeActor);
    renderers[i]->AddActor(base);
    renderers[i]->AddActor(labelActor);
    renderers[i]->AddActor(CubeEdges);
    renderers[i]->AddActor(CubeVertices);
    renderers[i]->AddActor(Triangles);
  // Set the background color.
    renderers[i]->SetBackground(color->GetColor3d("slate_grey").GetData());

  // Position the camera.
    renderers[i]->GetActiveCamera()->Dolly(1.2);
    renderers[i]->GetActiveCamera()->Azimuth(30);
    renderers[i]->GetActiveCamera()->Elevation(20);
    renderers[i]->ResetCamera();
    renderers[i]->ResetCameraClippingRange();
    if (i > 0)
    {
      renderers[i]->SetActiveCamera(renderers[0]->GetActiveCamera());
    }
  }
  // Setup viewports for the renderers
  int rendererSize = 300;
  int xGridDimensions = static_cast<int>(mcCases.size()) < 4 ?
                        static_cast<int>(mcCases.size()) : 4;
  int yGridDimensions = (static_cast<int>(mcCases.size()) - 1) / 4 + 1;
  std::cout << "x, y: " << xGridDimensions << " " << yGridDimensions << std::endl;
  renWin->SetSize(
    rendererSize * xGridDimensions, rendererSize * yGridDimensions);
  for (int row = 0; row < yGridDimensions; row++)
  {
    for (int col = 0; col < xGridDimensions; col++)
    {
      int index = row * xGridDimensions + col;

      // (xmin, ymin, xmax, ymax)
      double viewport[4] = {
        static_cast<double>(col) * rendererSize /
        (xGridDimensions * rendererSize),
        static_cast<double>(yGridDimensions - (row + 1)) * rendererSize /
        (yGridDimensions * rendererSize),
        static_cast<double>(col + 1) * rendererSize /
        (xGridDimensions * rendererSize),
        static_cast<double>(yGridDimensions - row) * rendererSize /
        (yGridDimensions * rendererSize)};
      renderers[index]->SetViewport(viewport);
    }
  }

  iren->Initialize();
  renWin->Render();
  iren->Start();
  return EXIT_SUCCESS;
}

namespace
{
void case1(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, OUT);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 1 - 00000001");
  }
  else
  {
    caseLabel->SetText("Case 1c - 11111110");
  }
}

void case2(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 2 - 00000011");
  }
  else
  {
    caseLabel->SetText("Case 2c - 11111100");
  }
}

void case3(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, OUT);
  scalars->InsertValue(2, IN);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 3 - 00000101");
  }
  else
  {
    caseLabel->SetText("Case 3c - 11111010");
  }
}

void case4(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, OUT);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, OUT);
  if (IN == 1) {
    caseLabel->SetText("Case 4 - 01000001");
  }
  else
  {
    caseLabel->SetText("Case 4c - 10111110");
  }
}

void case5(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, OUT);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, IN);
  scalars->InsertValue(5, IN);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 5 - 00110010");
  }
  else
  {
    caseLabel->SetText("Case 5c - 11001101");
  }
}

void case6(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, OUT);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, IN);
  scalars->InsertValue(4, IN);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 6 - 00011010");
  }
  else
  {
    caseLabel->SetText("Case 6c - 11100101");
  }
}

void case7(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 7 - 01000011");
  }
  else
  {
    caseLabel->SetText("Case 7c - 10111100");
  }
}

void case8(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, IN);
  scalars->InsertValue(5, IN);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
    if (IN == 1)
    {
      caseLabel->SetText("Case 8 - 00110011");
    }
    else
    {
      caseLabel->SetText("Case 8c - 11001100");
    }
}

void case9(vtkFloatArray *scalars,
           vtkVectorText *caseLabel,
           int IN, int OUT)
{
  scalars->InsertValue(0, OUT);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, IN);
  scalars->InsertValue(3, IN);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 9 - 01001110");
  }
  else
  {
    caseLabel->SetText("Case 9c - 10110001");
  }
}
void case10(vtkFloatArray *scalars,
            vtkVectorText *caseLabel,
            int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, OUT);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, IN);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, IN);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 10 - 01101001");
  }
  else
  {
    caseLabel->SetText("Case 10c - 10010110");
  }
}

void case11(vtkFloatArray *scalars,
            vtkVectorText *caseLabel,
            int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, OUT);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, OUT);
  scalars->InsertValue(4, IN);
  scalars->InsertValue(5, IN);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 11 - 01110001");
  }
  else
  {
    caseLabel->SetText("Case 11c - 10001110");
  }
}

void case12(vtkFloatArray *scalars,
            vtkVectorText *caseLabel,
            int IN, int OUT)
{
  scalars->InsertValue(0, OUT);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, IN);
  scalars->InsertValue(4, IN);
  scalars->InsertValue(5, IN);
  scalars->InsertValue(6, OUT);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 12 - 00111010");
  }
  else
  {
    caseLabel->SetText("Case 12c - 11000101");
  }
}

void case13(vtkFloatArray *scalars,
            vtkVectorText *caseLabel,
            int IN, int OUT)
{
  scalars->InsertValue(0, OUT);
  scalars->InsertValue(1, IN);
  scalars->InsertValue(2, OUT);
  scalars->InsertValue(3, IN);
  scalars->InsertValue(4, IN);
  scalars->InsertValue(5, OUT);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, OUT);
  if (IN == 1)
  {
    caseLabel->SetText("Case 13 - 01011010");
  }
  else
  {
    caseLabel->SetText("Case 13c - 10100101");
  }
}

void case14(vtkFloatArray *scalars,
            vtkVectorText *caseLabel,
            int IN, int OUT)
{
  scalars->InsertValue(0, IN);
  scalars->InsertValue(1, OUT);
  scalars->InsertValue(2, IN);
  scalars->InsertValue(3, IN);
  scalars->InsertValue(4, OUT);
  scalars->InsertValue(5, IN);
  scalars->InsertValue(6, IN);
  scalars->InsertValue(7, IN);
  if (IN == 1)
  {
    caseLabel->SetText("Case 14 - 11101101");
  }
  else
  {
    caseLabel->SetText("Case 14c - 00010010");
  }
}
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.8)

PROJECT(MarchingCases)

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

add_executable(MarchingCases MACOSX_BUNDLE MarchingCases.cxx )

target_link_libraries(MarchingCases ${VTK_LIBRARIES})

Download and Build MarchingCases

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

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

./MarchingCases

WINDOWS USERS

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