VTK-m  1.5
VTK-m

VTK-m is a toolkit of scientific visualization algorithms for emerging processor architectures. VTK-m supports the fine-grained concurrency for data analysis and visualization algorithms required to drive extreme scale computing by providing abstract models for data and execution that can be applied to a variety of algorithms across many different processor architectures.

You can find out more about the design of VTK-m on the VTK-m Wiki.

Learning Resources

  • A high-level overview is given in the IEEE Vis talk "[VTK-m: Accelerating the Visualization Toolkit for Massively Threaded Architectures]VTK-m Overview."
  • The VTK-m Users Guide provides extensive documentation. It is broken into multiple parts for learning and references at multiple different levels.
    • "Part 1: Getting Started" provides the introductory instruction for building VTK-m and using its high-level features.
    • "Part 2: Using VTK-m" covers the core fundamental components of VTK-m including data model, worklets, and filters.
    • "Part 3: Developing with VTK-m" covers how to develop new worklets and filters.
    • "Part 4: Advanced Development" covers topics such as new worklet types and custom device adapters.
  • A practical VTK-m Tutorial based in what users want to accomplish with VTK-m:
    • Building VTK-m and using existing VTK-m data structures and filters.
    • Algorithm development with VTK-m.
    • Writing new VTK-m filters.
  • Community discussion takes place on the VTK-m users email list.
  • Doxygen-generated nightly reference documentation is available online.

Contributing

There are many ways to contribute to VTK-m, with varying levels of effort.

Dependencies

VTK-m Requires:

  • C++11 Compiler. VTK-m has been confirmed to work with the following
    • GCC 4.8+
    • Clang 5.0+
    • XCode 5.0+
    • MSVC 2015+
    • Intel 17.0.4+
  • CMake
    • CMake 3.12+
    • CMake 3.13+ (for CUDA support)

Optional dependencies are:

  • CUDA Device Adapter
  • TBB Device Adapter
  • OpenMP Device Adapter
    • Requires a compiler that supports OpenMP >= 4.0.
  • OpenGL Rendering
    • The rendering module contains multiple rendering implementations including standalone rendering code. The rendering module also includes (optionally built) OpenGL rendering classes.
    • The OpenGL rendering classes require that you have a extension binding library and one rendering library. A windowing library is not needed except for some optional tests.
  • Extension Binding
  • On Screen Rendering
    • OpenGL Driver
    • Mesa Driver
  • On Screen Rendering Tests
  • Headless Rendering

VTK-m has been tested on the following configurations:c

  • On Linux
    • GCC 4.8.5, 5.4, 6.5, 7.4, 8.2, 9.2; Clang 5, 8; Intel 17.0.4; 19.0.0
    • CMake 3.12, 3.13, 3.16, 3.17
    • CUDA 9.2.148, 10.0.130, 10.1.105, 10.2.89
    • TBB 4.4 U2, 2017 U7
  • On Windows
    • Visual Studio 2015, 2017
    • CMake 3.12, 3.17
    • CUDA 10.1
    • TBB 2017 U3, 2018 U2
  • On MacOS
    • AppleClang 9.1
    • CMake 3.12
    • TBB 2018

Building

VTK-m supports all majors platforms (Windows, Linux, OSX), and uses CMake to generate all the build rules for the project. The VTK-m source code is available from the VTK-m download page or by directly cloning the [VTK-m git repository].

The basic procedure for building VTK-m is to unpack the source, create a build directory, run CMake in that build directory (pointing to the source) and then build. Here are some example *nix commands for the process (individual commands may vary).

$ tar xvzf ~/Downloads/vtk-m-v1.4.0.tar.gz
$ mkdir vtkm-build
$ cd vtkm-build
$ cmake-gui ../vtk-m-v1.4.0
$ cmake --build -j . # Runs make (or other build program)

A more detailed description of building VTK-m is available in the [VTK-m Users Guide].

Example

The VTK-m source distribution includes a number of examples. The goal of the VTK-m examples is to illustrate specific VTK-m concepts in a consistent and simple format. However, these examples only cover a small part of the capabilities of VTK-m.

Below is a simple example of using VTK-m to load a VTK image file, run the Marching Cubes algorithm on it, and render the results to an image:

#include <vtkm/Bounds.h>
#include <vtkm/Range.h>
vtkm::io::VTKDataSetReader reader("path/to/vtk_image_file.vtk");
vtkm::cont::DataSet inputData = reader.ReadDataSet();
std::string fieldName = "scalars";
inputData.GetPointField(fieldName).GetRange(&range);
vtkm::Float64 isovalue = range.Center();
// Create an isosurface filter
filter.SetIsoValue(0, isovalue);
filter.SetActiveField(fieldName);
vtkm::cont::DataSet outputData = filter.Execute(inputData);
// compute the bounds and extends of the input data
vtkm::Bounds coordsBounds = inputData.GetCoordinateSystem().GetBounds();
// setup a camera and point it to towards the center of the input data
camera.ResetToBounds(coordsBounds);
vtkm::cont::ColorTable colorTable("inferno");
// Create a mapper, canvas and view that will be used to render the scene
vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);
// Render an image of the output isosurface
outputData.GetCoordinateSystem(),
outputData.GetField(fieldName),
colorTable));
vtkm::rendering::View3D view(scene, mapper, canvas, camera, bg);
view.Initialize();
view.Paint();
view.SaveAs("demo_output.png");

A minimal CMakeLists.txt such as the following one can be used to build this example.

project(example)
set(VTKm_DIR "/somepath/lib/cmake/vtkm-XYZ")
find_package(VTKm REQUIRED)
add_executable(example example.cxx)
target_link_libraries(example vtkm_cont vtkm_rendering)

License

VTK-m is distributed under the OSI-approved BSD 3-clause License. See LICENSE.txt for details.

vtkm::rendering::Color
It's a color!
Definition: Color.h:28
vtkm::cont::ColorTable
Color Table for coloring arbitrary fields.
Definition: cont/ColorTable.h:99
MapperRayTracer.h
CanvasRayTracer.h
vtkm::cont::DataSet::GetCoordinateSystem
const VTKM_CONT vtkm::cont::CoordinateSystem & GetCoordinateSystem(vtkm::Id index=0) const
vtkm::rendering::Actor
Definition: Actor.h:26
vtkm::cont::DataSet
Definition: DataSet.h:28
ColorTable.h
VTKDataSetReader.h
vtkm::Range::Center
VTKM_EXEC_CONT vtkm::Float64 Center() const
Returns the center of the range.
Definition: Range.h:104
vtkm::filter::Contour::SetIsoValue
VTKM_FILTER_EXPORT void SetIsoValue(vtkm::Float64 v)
Definition: filter/Contour.h:47
Scene.h
Bounds.h
vtkm::cont::DataSet::GetCellSet
const VTKM_CONT vtkm::cont::DynamicCellSet & GetCellSet() const
Definition: DataSet.h:236
vtkm::cont::CoordinateSystem::GetBounds
VTKM_CONT vtkm::Bounds GetBounds() const
Definition: CoordinateSystem.h:90
vtkm::filter::Contour
generate isosurface(s) from a Volume
Definition: filter/Contour.h:32
Range.h
vtkm::cont::DataSet::GetPointField
const VTKM_CONT vtkm::cont::Field & GetPointField(const std::string &name) const
Returns the first point field that matches the provided name.
Definition: DataSet.h:123
vtkm::filter::FilterDataSetWithField::SetActiveField
VTKM_CONT void SetActiveField(const std::string &name, vtkm::cont::Field::Association association=vtkm::cont::Field::Association::ANY)
Choose the field to operate on.
Definition: FilterDataSetWithField.h:48
vtkm::Bounds
Represent an axis-aligned 3D bounds in space.
Definition: Bounds.h:29
vtkm::rendering::Scene::AddActor
void AddActor(const vtkm::rendering::Actor &actor)
vtkm::rendering::MapperRayTracer
Definition: MapperRayTracer.h:24
vtkm::io::VTKDataSetReader
Definition: VTKDataSetReader.h:20
vtkm::rendering::Camera::ResetToBounds
void ResetToBounds(const vtkm::Bounds &dataBounds)
Set up the camera to look at geometry.
vtkm::rendering::View3D
Definition: View3D.h:24
Camera.h
vtkm::Float64
double Float64
Definition: Types.h:155
vtkm::rendering::CanvasRayTracer
Definition: CanvasRayTracer.h:23
Actor.h
Color.h
vtkm::rendering::Camera
Definition: Camera.h:28
vtkm::cont::DataSet::GetField
const VTKM_CONT vtkm::cont::Field & GetField(vtkm::Id index) const
vtkm::rendering::Scene
Definition: Scene.h:27
vtkm::cont::Field::GetRange
VTKM_CONT void GetRange(vtkm::Range *range, TypeList) const
Definition: Field.h:92
vtkm::filter::Filter::Execute
VTKM_CONT vtkm::cont::DataSet Execute(const vtkm::cont::DataSet &input)
Executes the filter on the input and produces a result dataset.
Contour.h
View3D.h
vtkm::Range
Represent a continuous scalar range of values.
Definition: Range.h:30