707970f492
This fixes the three following issues with StorageBasic. 1. Memory that was allocated by VTK-m and Stolen by the user needed the proper free function called which is generally StorageBasicAllocator::deallocate. But that was hard for the user to hold onto. So now we provide a function pointer to the correct free function. 2. Memory that was allocated outside of VTK-m was impossible to transfer to VTK-m as we didn't know how to free it. This is now resolved by allowing the user to specify a free function to be called on release. 3. When the CUDA backend allocates memory for an ArrayHandle that has no control representation, and the location we are running on supports concurrent managed access we want to specify that cuda managed memory as also the host memory. This requires that StorageBasic be able to call an arbitrary new delete function which is chosen at runtime. |
||
---|---|---|
CMake | ||
data | ||
docs | ||
examples | ||
Utilities | ||
vtkm | ||
.clang-format | ||
.gitattributes | ||
CMakeLists.txt | ||
CONTRIBUTING.md | ||
CTestConfig.cmake | ||
CTestCustom.cmake.in | ||
LICENSE.txt | ||
README.md | ||
version.txt |
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.
-
Ask a question on the VTK-m users email list.
-
Submit new or add to discussions of a feature requests or bugs on the VTK-m Issue Tracker.
-
Submit a Pull Request to improve VTK-m
- See CONTRIBUTING.md for detailed instructions on how to create a Pull Request.
- See the VTK-m Coding Conventions that must be followed for contributed code.
-
Submit an Issue or Pull Request for the VTK-m Users Guide
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.3+ (for any build)
- CMake 3.9+ (for CUDA build)
Optional dependencies are:
- CUDA Device Adapter
- TBB Device Adapter
- 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
- OS Mesa
- EGL Driver
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");
inputData = reader.ReadDataSet();
vtkm::Float64 isovalue = 100.0f;
std::string fieldName = "pointvar";
// Create an isosurface filter
vtkm::filter::MarchingCubes filter;
filter.SetIsoValue(0, isovalue);
vtkm::filter::Result result = filter.Execute( inputData,
inputData.GetField(fieldName) );
filter.MapFieldOntoOutput(result, inputData.GetField(fieldName));
// 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
vtkm::cont::DataSet& outputData = result.GetDataSet();
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.