Skip to content


# Decimation

VTKEx/Cxx/Meshes/Decimation

### Description

This example decimates a mesh using progressive decimation. The SetTargetReduction function specifies how many triangles should reduced by specifying the percentage (0,1) of triangles to be removed. For example, if the mesh contains 100 triangles and SetTargetReduction(.90) is called, after the decimation there will be approximately 10 triangles - a 90% reduction.

The implementation of vtkDecimatePro is similar to the algorithm originally described in "Decimation of Triangle Meshes", Proc Siggraph `92, with three major differences. First, this algorithm does not necessarily preserve the topology of the mesh. Second, it is guaranteed to give the a mesh reduction factor specified by the user (as long as certain constraints are not set - see Caveats). Third, it is set up generate progressive meshes, that is a stream of operations that can be easily transmitted and incrementally updated (see Hugues Hoppe's Siggraph '96 paper on progressive meshes).

Seealso

QuadricClustering and QuadricDecimation.

Other languages

See (Python)

Question

If you have a simple question about this example contact us at VTKExProject If your question is more complex and may require extended discussion, please use the VTK Discourse Forum

### Code

Decimation.cxx

    #include <vtkXMLPolyDataReader.h>
    #include <vtkPolyData.h>
    #include <vtkSphereSource.h>
    #include <vtkTriangleFilter.h>
    #include <vtkDecimatePro.h>
    #include <vtkSmartPointer.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkProperty.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkRenderer.h>
    #include <vtkCamera.h>

    #include <vtkNamedColors.h>

    int main(int argc, char *argv[])
    {
      vtkSmartPointer<vtkPolyData> inputPolyData;
      if(argc > 1)
      {
        vtkSmartPointer<vtkXMLPolyDataReader> reader =
          vtkSmartPointer<vtkXMLPolyDataReader>::New();
        reader->SetFileName(argv[1]);
        vtkSmartPointer<vtkTriangleFilter> triangles =
          vtkSmartPointer<vtkTriangleFilter>::New();
        triangles->SetInputConnection(reader->GetOutputPort());
        triangles->Update();
        inputPolyData = triangles->GetOutput();
      }
      else
      {
        vtkSmartPointer<vtkSphereSource> sphereSource =
          vtkSmartPointer<vtkSphereSource>::New();
        sphereSource->SetThetaResolution(30);
        sphereSource->SetPhiResolution(15);
        sphereSource->Update();
        inputPolyData = sphereSource->GetOutput();
      }

      float reduction = .9; // 90% reduction
      if (argc > 2)
      {
        reduction = atof(argv[2]);
      }
      vtkSmartPointer<vtkNamedColors> colors =
        vtkSmartPointer<vtkNamedColors>::New();
      std::cout << "Before decimation" << std::endl << "------------" << std::endl;
      std::cout << "There are " << inputPolyData->GetNumberOfPoints() << " points." << std::endl;
      std::cout << "There are " << inputPolyData->GetNumberOfPolys() << " polygons." << std::endl;

      vtkSmartPointer<vtkDecimatePro> decimate =
        vtkSmartPointer<vtkDecimatePro>::New();
      decimate->SetInputData(inputPolyData);
      decimate->SetTargetReduction(reduction);
      decimate->PreserveTopologyOn();
      decimate->Update();

      vtkSmartPointer<vtkPolyData> decimated =
        vtkSmartPointer<vtkPolyData>::New();
      decimated->ShallowCopy(decimate->GetOutput());

      std::cout << "After decimation" << std::endl << "------------" << std::endl;

      std::cout << "There are " << decimated->GetNumberOfPoints() << " points." << std::endl;
      std::cout << "There are " << decimated->GetNumberOfPolys() << " polygons." << std::endl;
      std::cout << "Reduction: " <<
        static_cast<double>((inputPolyData->GetNumberOfPolys() - decimated->GetNumberOfPolys())) /
        static_cast<double>(inputPolyData->GetNumberOfPolys()) << std::endl;

      vtkSmartPointer<vtkPolyDataMapper> inputMapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
      inputMapper->SetInputData(inputPolyData);

      vtkSmartPointer<vtkProperty> backFace =
        vtkSmartPointer<vtkProperty>::New();
      backFace->SetColor(colors->GetColor3d("gold").GetData());

      vtkSmartPointer<vtkActor> inputActor =
        vtkSmartPointer<vtkActor>::New();
      inputActor->SetMapper(inputMapper);
      inputActor->GetProperty()->SetInterpolationToFlat();
      inputActor->GetProperty()->SetColor(colors->GetColor3d("flesh").GetData());
      inputActor->SetBackfaceProperty(backFace);

      vtkSmartPointer<vtkPolyDataMapper> decimatedMapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
      decimatedMapper->SetInputData(decimated);

      vtkSmartPointer<vtkActor> decimatedActor =
        vtkSmartPointer<vtkActor>::New();
      decimatedActor->SetMapper(decimatedMapper);
      decimatedActor->GetProperty()->SetColor(colors->GetColor3d("flesh").GetData());
      decimatedActor->GetProperty()->SetInterpolationToFlat();
      decimatedActor->SetBackfaceProperty(backFace);

      // There will be one render window
      vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();
      renderWindow->SetSize(600, 300);

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

      // Define viewport ranges
      // (xmin, ymin, xmax, ymax)
      double leftViewport[4] = {0.0, 0.0, 0.5, 1.0};
      double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};

      // Setup both renderers
      vtkSmartPointer<vtkRenderer> leftRenderer =
        vtkSmartPointer<vtkRenderer>::New();
      renderWindow->AddRenderer(leftRenderer);
      leftRenderer->SetViewport(leftViewport);
      leftRenderer->SetBackground(.6, .5, .4);

      vtkSmartPointer<vtkRenderer> rightRenderer =
        vtkSmartPointer<vtkRenderer>::New();
      renderWindow->AddRenderer(rightRenderer);
      rightRenderer->SetViewport(rightViewport);
      rightRenderer->SetBackground(.4, .5, .6);

      // Add the sphere to the left and the cube to the right
      leftRenderer->AddActor(inputActor);
      rightRenderer->AddActor(decimatedActor);

      // Shared camera
      // Shared camera looking down the -y axis
      vtkSmartPointer<vtkCamera> camera =
        vtkSmartPointer<vtkCamera>::New();
      camera->SetPosition (0, -1, 0);
      camera->SetFocalPoint (0, 0, 0);
      camera->SetViewUp (0, 0, 1);
      camera->Elevation(30);
      camera->Azimuth(30);

      leftRenderer->SetActiveCamera(camera);
      rightRenderer->SetActiveCamera(camera);

      leftRenderer->ResetCamera();
      leftRenderer->ResetCameraClippingRange();

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

      return EXIT_SUCCESS;
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

    project(Decimation)

    find_package(VTK COMPONENTS
      vtkCommonColor
      vtkCommonCore
      vtkCommonDataModel
      vtkFiltersCore
      vtkFiltersSources
      vtkIOXML
      vtkInteractionStyle
      vtkRenderingContextOpenGL2
      vtkRenderingCore
      vtkRenderingFreeType
      vtkRenderingGL2PSOpenGL2
      vtkRenderingOpenGL2 QUIET)
    if (NOT VTK_FOUND)
      message("Skipping Decimation: ${VTK_NOT_FOUND_MESSAGE}")
      return ()
    endif()
    message (STATUS "VTK_VERSION: ${VTK_VERSION}")
    if (VTK_VERSION VERSION_LESS "8.90.0")
      # old system
      include(${VTK_USE_FILE})
      add_executable(Decimation MACOSX_BUNDLE Decimation.cxx )
      target_link_libraries(Decimation PRIVATE ${VTK_LIBRARIES})
    else ()
      # include all components
      add_executable(Decimation MACOSX_BUNDLE Decimation.cxx )
      target_link_libraries(Decimation PRIVATE ${VTK_LIBRARIES})
      # vtk_module_autoinit is needed
      vtk_module_autoinit(
        TARGETS Decimation
        MODULES ${VTK_LIBRARIES}
        )
    endif ()

### Download and Build Decimation

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

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

    ./Decimation

WINDOWS USERS

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