Go to file
Robert Maynard d8cc067caa Remove DeviceAdapterError as it isn't needed any more.
Fixes #277

DeviceAdapterError existed to make sure that the default device adapter
template was being handled properly. Since the default device adapter doesn't
exist, and nothing is templated over it we can now remove DeviceAdapterError.
2019-04-18 15:09:57 -04:00
benchmarking benchmarking cmake code simplified 2019-04-18 10:29:24 -04:00
CMake conslidate the license statement 2019-04-17 10:57:13 -06:00
data Add sample input 2017-09-06 14:05:15 -06:00
docs conslidate the license statement 2019-04-17 10:57:13 -06:00
examples Merge topic 'correct_openmp_timeouts' 2019-04-18 08:05:12 -04:00
Utilities benchCompare now handles the new Benchmark syntax 2019-03-08 13:46:54 -05:00
vtkm Remove DeviceAdapterError as it isn't needed any more. 2019-04-18 15:09:57 -04:00
.clang-format Allow clang-format to pass more empty lines 2017-05-31 09:35:26 -06:00
.gitattributes Add update script for optionparser third party library 2019-03-26 15:34:20 -06:00
.gitignore Add a point-oscillator filter + example 2018-07-18 09:33:06 -04:00
CMakeLists.txt conslidate the license statement 2019-04-17 10:57:13 -06:00
CONTRIBUTING.md Add some instructions for fixing common git problems 2018-07-27 11:23:00 -06:00
CTestConfig.cmake conslidate the license statement 2019-04-17 10:57:13 -06:00
CTestCustom.cmake.in conslidate the license statement 2019-04-17 10:57:13 -06:00
LICENSE.txt update LICENSE.txt file 2019-04-17 10:57:13 -06:00
README.md Update what VTK-m versions of dependencies we test against. 2019-04-04 09:33:00 -04:00
version.txt Release VTK-m 1.3.0 2018-11-26 11:12:44 -05:00

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."

  • 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.
  • 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 3.3+
    • XCode 5.0+
    • MSVC 2015+
  • CMake
    • CMake 3.8+ (for any build)
    • CMake 3.9+ (for CUDA build or OpenMP build)
    • CMake 3.11+ (for Visual Studio generator)

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.0, 6.4.0, 7.3.0, Clang 5.0, 6.0, 7.0, Intel 17.0.4
    • CMake 3.13.3, 3.14.1
    • CUDA 9.2.148, 10.0.130, 10.1.105
    • TBB 4.4 U2, 2017 U7
  • On Windows
    • Visual Studio 2015, 2017
    • CMake 3.8.2, 3.11.1, 3.12.4
    • CUDA 10.1
    • TBB 2017 U3, 2018 U2
  • On MacOS
    • AppleClang 9.1
    • CMake 3.12.3
    • 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.

$ git clone https://gitlab.kitware.com/vtk/vtk-m.git
$ mkdir vtkm-build
$ cd vtkm-build
$ cmake-gui ../vtk-m
$ make -j<N>
$ make test

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:

vtkm::io::reader::VTKDataSetReader reader("path/to/vtk_image_file");
vtkm::cont::DataSet inputData = reader.ReadDataSet();
std::string fieldName = "scalars";

vtkm::Range range;
inputData.GetPointField(fieldName).GetRange(&range);
vtkm::Float64 isovalue = range.Center();

// Create an isosurface filter
vtkm::filter::MarchingCubes 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();
vtkm::Vec<vtkm::Float64,3> totalExtent( coordsBounds.X.Length(),
                                        coordsBounds.Y.Length(),
                                        coordsBounds.Z.Length() );
vtkm::Float64 mag = vtkm::Magnitude(totalExtent);
vtkm::Normalize(totalExtent);

// setup a camera and point it to towards the center of the input data
vtkm::rendering::Camera camera;
camera.ResetToBounds(coordsBounds);

camera.SetLookAt(totalExtent*(mag * .5f));
camera.SetViewUp(vtkm::make_Vec(0.f, 1.f, 0.f));
camera.SetClippingRange(1.f, 100.f);
camera.SetFieldOfView(60.f);
camera.SetPosition(totalExtent*(mag * 2.f));
vtkm::cont::ColorTable colorTable("inferno");

// Create a mapper, canvas and view that will be used to render the scene
vtkm::rendering::Scene scene;
vtkm::rendering::MapperRayTracer mapper;
vtkm::rendering::CanvasRayTracer canvas(512, 512);
vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);

// Render an image of the output isosurface
scene.AddActor(vtkm::rendering::Actor(outputData.GetCellSet(),
                                      outputData.GetCoordinateSystem(),
                                      outputData.GetField(fieldName),
                                      colorTable));
vtkm::rendering::View3D view(scene, mapper, canvas, camera, bg);
view.Initialize();
view.Paint();
view.SaveAs("demo_output.pnm");

License

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