VTK

https://docs.vtk.org/en/latest/
Admin
VTK (Visualization Toolkit) is an open-source 3D computer graphics, image processing, and...
Tokens:456,398
Snippets:5,335
Trust Score:9.8
Update:4 months ago
Show doc for...
Tokens:
Raw
### Basic QVTKRenderWindowInteractor Setup

Source: https://docs.vtk.org/en/latest/api/python/vtkmodules/vtkmodules.qt.html

This snippet demonstrates the basic setup for using QVTKRenderWindowInteractor in a PyQt5 application. It initializes the Qt application and the QVTK widget, then starts the render window interactor.

```python
import sys
import PyQt5
from PyQt5.QtWidgets import QApplication
from vtkmodules.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor

app = QApplication(sys.argv)

widget = QVTKRenderWindowInteractor()
widget.Initialize()
widget.Start()

renwin = widget.GetRenderWindow()

```

--------------------------------

### Install VTK in a virtual environment (Linux)

Source: https://docs.vtk.org/en/latest/getting_started/index.html

Create a virtual environment and install VTK locally on Linux.

```bash
python -m venv ./env
source ./env/bin/activate
pip install vtk

```

--------------------------------

### Install VTK in a virtual environment (Windows cmd.exe)

Source: https://docs.vtk.org/en/latest/getting_started/index.html

Create a virtual environment and install VTK locally on Windows using cmd.exe.

```bash
python -m venv env
.\env\activate.bat
pip install vtk

```

--------------------------------

### Run Developer Setup Script

Source: https://docs.vtk.org/en/latest/developers_guide/develop_quickstart.html

Execute the setup script to prepare your VTK work tree and configure Git remotes and aliases.

```bash
$ ./Utilities/SetupForDevelopment.sh

```

--------------------------------

### Writing Build and Install Files

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModule.html

Use file(WRITE) to create build and install files. It is recommended to store the install file under a CMakeFiles/ directory in the build tree.

```cmake
file(WRITE "${build_file}")
file(WRITE "${install_file}")


```

--------------------------------

### Install VTK in a virtual environment (Windows PowerShell)

Source: https://docs.vtk.org/en/latest/getting_started/index.html

Create a virtual environment and install VTK locally on Windows using PowerShell.

```powershell
python -m venv env
.\env\Activate.ps1
pip install vtk

```

--------------------------------

### Get VTK Example Data Directory

Source: https://docs.vtk.org/en/latest/api/python/vtkmodules/vtkmodules.util.misc.html

Retrieves the path to the VTK example data directory.

```python
vtkGetDataRoot()
```

--------------------------------

### Install Documentation Dependencies (Windows)

Source: https://docs.vtk.org/en/latest/advanced/build_documentation.html

Installs the required Python packages for building VTK documentation on Windows.

```bash
py -m pip install -r requirements.txt

```

--------------------------------

### QVTKRenderWindowInteractor Example

Source: https://docs.vtk.org/en/latest/api/python/vtkmodules/vtkmodules.qt.QVTKRenderWindowInteractor.html

A basic example demonstrating the usage of the QVTKRenderWindowInteractor class.

```python
vtkmodules.qt.QVTKRenderWindowInteractor.QVTKRenderWidgetConeExample()
```

--------------------------------

### main Function

Source: https://docs.vtk.org/en/latest/api/python/vtkmodules/vtkmodules.gtk.GtkVTKRenderWindow.html

Entry point for running the GtkVTKRenderWindow example.

```APIDOC
## Function main()

Entry point for the application. This function typically initializes GTK and the GtkVTKRenderWindow, and starts the GTK main loop.
```

--------------------------------

### Install Documentation Dependencies (Linux/macOS)

Source: https://docs.vtk.org/en/latest/advanced/build_documentation.html

Installs the required Python packages for building VTK documentation on Linux and macOS.

```bash
python3 -m pip install -r requirements.txt

```

--------------------------------

### vtkmodules.gtk.GtkGLExtVTKRenderWindow.main Function

Source: https://docs.vtk.org/en/latest/api/python/vtkmodules/vtkmodules.gtk.GtkGLExtVTKRenderWindow.html

Entry point for running the GtkGLExtVTKRenderWindow example.

```APIDOC
## Function vtkmodules.gtk.GtkGLExtVTKRenderWindow.main()

### Description
This function serves as the main entry point for running an example or application utilizing the GtkGLExtVTKRenderWindow.

### Usage
```python
vtkmodules.gtk.GtkGLExtVTKRenderWindow.main()
```
```

--------------------------------

### Install VTK from PyPI

Source: https://docs.vtk.org/en/latest/advanced/available_python_wheels.html

Installs the default VTK Python wheel from the Python Package Index (PyPI). This wheel typically uses the default rendering backend leveraging hardware graphics.

```bash
pip install vtk

```

--------------------------------

### Example VTKPythonAlgorithmBase Implementation

Source: https://docs.vtk.org/en/latest/api/python/vtkmodules/vtkmodules.util.vtkAlgorithm.html

Demonstrates how to subclass VTKPythonAlgorithmBase to create a custom VTK algorithm. This example shows setting up input/output ports and implementing RequestInformation and RequestData methods for reading data from an HDF5 file.

```python
class HDF5Source(VTKPythonAlgorithmBase):
    def __init__(self):
        VTKPythonAlgorithmBase.__init__(self, nInputPorts=0, nOutputPorts=1, outputType='vtkImageData')

def RequestInformation(self, request, inInfo, outInfo):
    f = h5py.File("foo.h5", 'r')
    dims = f['RTData'].shape[::-1]
    info = outInfo.GetInformationObject(0)
    info.Set(vtkmodules.vtkCommonExecutionModel.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT(),
        (0, dims[0]-1, 0, dims[1]-1, 0, dims[2]-1), 6)
    return 1

def RequestData(self, request, inInfo, outInfo):
    f = h5py.File("foo.h5", 'r')
    data = f['RTData'][:]
    output = dsa.WrapDataObject(vtkmodules.vtkCommonDataModel.vtkImageData.GetData(outInfo))
    output.SetDimensions(data.shape)
    output.PointData.append(data.flatten(), 'RTData')
    output.PointData.SetActiveScalars('RTData')
    return 1

```

--------------------------------

### Install Node.js and Emscripten SDK on Windows

Source: https://docs.vtk.org/en/latest/advanced/build_wasm_emscripten.html

Installs Node.js using fnm and sets up the Emscripten SDK environment in PowerShell. Ensure Emscripten is added to your PATH.

```powershell
# In Powershell
# Download and install fnm:
winget install Schniz.fnm
# Download and install Node.js
fnm install 24.0.1
fnm env --use-on-cd --shell power-shell | Out-String | Invoke-Expression
fnm use 24.0.1

git clone https://github.com/emscripten-core/emsdk.git
.\/emsdk\/emsdk install 4.0.20
$env:PATH="$PWD\emsdk\upstream\bin;$PWD\emsdk\upstream\emscripten;$env:PATH"

```

--------------------------------

### Install Node.js and Emscripten SDK on macOS/Linux

Source: https://docs.vtk.org/en/latest/advanced/build_wasm_emscripten.html

Installs Node.js using fnm and sets up the Emscripten SDK environment. Ensure Emscripten is added to your PATH.

```bash
# Download and install fnm:
curl -o- https://fnm.vercel.app/install | bash
# Download and install Node.js
fnm install 24.0.1
fnm use 24.0.1

# Download and install EMSDK
git clone https://github.com/emscripten-core/emsdk.git
./emsdk/emsdk install 4.0.20
export PATH=$PWD/emsdk/upstream/bin:$PWD/emsdk/upstream/emscripten:$PATH

```

--------------------------------

### Verify VTK installation

Source: https://docs.vtk.org/en/latest/getting_started/index.html

Import VTK and print its version in an interactive Python environment.

```python
>>> import vtk
>>> print(vtk.__version__)
9.2.6

```

--------------------------------

### Build Dawn from Source

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/README.html

Steps to clone Dawn, checkout a specific version, build it, and install it to a specified directory. Ensure DAWN_INSTALL_DIR is set correctly.

```bash
git clone https://github.com/google/dawn dawn && cd dawn
git checkout v20260421.125655
cmake -S . -B out/Debug -GNinja -DDAWN_FETCH_DEPENDENCIES=ON -DDAWN_ENABLE_INSTALL=ON
cmake --build out/Debug
cmake --install out/Debug --prefix ${DAWN_INSTALL_DIR}
```

--------------------------------

### Get Real Target for a Kit Module

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModule.html

Retrieves the actual CMake target for a kit module. Similar to _vtk_module_real_target, this is useful for direct manipulation of kit target properties or install rules.

```cmake
_vtk_module_real_target_kit(<var> <kit>)
```

--------------------------------

### WebGPU Compute Pipeline Execution Example

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/doc/webgpu-compute-api-user.html

Demonstrates the complete workflow for setting up and executing a compute shader using vtkWebGPUComputePipeline. This includes creating input and output buffers, configuring the compute pass, dispatching work, and reading results back.

```cpp
  std::vector<float> inputValues;
  // ...
  // Fill the input vector with data
  // ...

  // Creating the input buffer to the compute shader
  vtkNew<vtkWebGPUComputeBuffer> inputBuffer;
  inputBuffer->SetGroup(0);
  inputBuffer->SetBinding(0);
  inputBuffer->SetMode(vtkWebGPUComputeBuffer::BufferMode::READ_ONLY_COMPUTE_STORAGE);
  inputBuffer->SetData(inputValues);
  inputBuffer->SetDataType(vtkWebGPUComputeBuffer::BufferDataType::STD_VECTOR);

  // Creating the output buffer of the compute shader
  vtkNew<vtkWebGPUComputeBuffer> outputBuffer;
  outputBuffer->SetGroup(0);
  outputBuffer->SetBinding(1);
  outputBuffer->SetMode(vtkWebGPUComputeBuffer::BufferMode::READ_WRITE_MAP_COMPUTE_STORAGE);
  outputBuffer->SetByteSize(inputValues.size() * sizeof(float));

  // Creating the compute pipeline
  vtkNew<vtkWebGPUComputePipeline> computePipeline;
  vtkSmartPointer<vtkWebGPUComputePass> computePass = computePipeline->CreateComputePass();
  computePass->SetShaderSource(computeShaderSource);
  computePass->SetShaderEntryPoint("computeMainFunction");
  computePass->AddBuffer(inputBuffer);
  // Getting the index of the output buffer for later mapping with ReadBufferFromGPU()
  int outputBufferIndex = computePipeline->AddBuffer(outputBuffer);

  computePass->SetWorkgroups(workgroupsX, workgroupsY, workgroupsZ);

  // We've set up everything, ready to dispatch
  computePass->Dispatch();

  // Vector that will contain the results of the compute shader
  std::vector<float> outputData(outputBufferSize);

  // Function called by ReadBufferFromGPU() whose purpose is to copy
  // the data into your result buffer (outputData here).
  auto onBufferMapped = [](const void* mappedData, void* userdata)
  {
    std::vector<float>* outputDataVector = reinterpret_cast<std::vector<float>*>(userdata);

    // You must know in advance how many elements you're going to read from the mappedData.
    // We're using the size of outputDataVector here because we resized it to just the right
    // size so that's just the right number of elements. If you don't want or can't use a
    // std::vector for that purpose, you can still pass the number of elements as the third
    // argument of ReadBufferFromGPU().
    vtkIdType elementCount = outputDataVector->size();

    const float* mappedDataAsF32 = static_cast<const float*>(mappedData);
    for (int i = 0; i < elementCount; i++)
    {
      (*outputDataVector)[i] = mappedDataAsF32[i];
    }
  };

  // Mapping the buffer on the CPU to get the results from the GPU
  computePass->ReadBufferFromGPU(outputBufferIndex, onBufferMapped, &outputData);
  // Update() to actually execute WebGPU commands. Without this, the compute shader won't execute.
  // Update() is called on the compute pipeline and not the compute pass because it is the
  // compute pipeline that orchestrates the execution of all compute passes
  computePipeline->Update();

  // ... Do something with the output data

```

--------------------------------

### Get Real Target for a Module

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModule.html

Retrieves the actual CMake target for a given module. Use this when needing to set CMake-level target properties or install rules directly on the module's target.

```cmake
_vtk_module_real_target(<var> <module>)
```

--------------------------------

### Install Python Requirements for VTK Build Tree

Source: https://docs.vtk.org/en/latest/advanced/build_documentation.html

Installs necessary Python packages when building documentation within an existing VTK build tree. Use either pip install or pip install --user.

```bash
pip install -r Documentation\docs\requirements.txt

```

```bash
pip install --user -r Documentation\docs\requirements.txt

```

--------------------------------

### Fetch Pre-built Dawn Binaries (Windows)

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/README.html

Downloads and installs pre-built Dawn binaries for Windows. Sets the DAWN_INSTALL_DIR environment variable. Use PowerShell for execution.

```powershell
cd "$env:VTK_SOURCE_DIR"
$env:CMAKE_CONFIGURATION="windows"; cmake -P .gitlab/ci/download_dawn.cmake
$env:DAWN_INSTALL_DIR="$env:VTK_SOURCE_DIR\.gitlab\dawn"
```

--------------------------------

### Changelog Markdown Example

Source: https://docs.vtk.org/en/latest/developers_guide/develop_quickstart.html

Example of a markdown file to be added to Documentation/release/dev for changelog updates.

```markdown
## Development title

A new feature that does this and that has been introduced.
This specific issue has been fixed in this particular way.


```

--------------------------------

### Configure and Create WebGPU Compute Pipeline

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/doc/webgpu-compute-api-user.html

Create a vtkWebGPUConfiguration to specify backend and power preference, then use it to set up a vtkWebGPUComputePipeline for custom device execution.

```cpp
// Creating a vtkWebGPUConfiguration
vtkNew<vtkWebGPUConfiguration> wgpuConfig;
wgpuConfig->SetBackend(vtkWebGPUConfiguration::BackendType::Vulkan);
wgpuConfig->SetPowerPreference(vtkWebGPUConfiguration::PowerPreferenceType::LowPower);

// Creating a vtkWebGPUComputePipeline to use custom device
vtkNew<vtkWebGPUComputePipeline> computePipeline;
computePipeline->SetWGPUConfiguration(wgpuConfig);

```

--------------------------------

### Fetch Pre-built Dawn Binaries (Linux)

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/README.html

Downloads and installs pre-built Dawn binaries for Linux. Sets the DAWN_INSTALL_DIR environment variable.

```bash
cd "${VTK_SOURCE_DIR}"
CMAKE_CONFIGURATION="fedora" cmake -P .gitlab/ci/download_dawn.cmake
export DAWN_INSTALL_DIR="${VTK_SOURCE_DIR}/.gitlab/dawn"
```

--------------------------------

### Add Python Package

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModuleWrapPython.html

Installs Python packages associated with a VTK module. Each package should be installed independently.

```cmake
vtk_module_add_python_package(<module>
  PACKAGE <package>
  FILES <files>...
  [MODULE_DESTINATION <destination>]
  [COMPONENT <component>])

```

--------------------------------

### Create and Activate Virtual Environment (Windows)

Source: https://docs.vtk.org/en/latest/advanced/build_documentation.html

Sets up a Python virtual environment for building documentation on Windows systems.

```bash
cd Documentation\docs

py -m venv .venv
.\.venv\Scripts\activate

```

--------------------------------

### Install Xcode Command Line Tools on macOS

Source: https://docs.vtk.org/en/latest/build_instructions/build.html

Installs the necessary command line tools for Xcode on macOS.

```bash
xcode-select --install

```

--------------------------------

### Check VTK Install Destinations

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModule.html

Verifies that installation destinations are relative to CMAKE_INSTALL_PREFIX. Raises an error if any destination is invalid.

```cmake
_vtk_module_check_destinations(<prefix> [<suffix>...])

```

--------------------------------

### Create and Activate Virtual Environment (Linux/macOS)

Source: https://docs.vtk.org/en/latest/advanced/build_documentation.html

Sets up a Python virtual environment for building documentation on Linux and macOS systems.

```bash
cd Documentation/docs

python3 -m venv .venv
source .venv/bin/activate

```

--------------------------------

### Fetch Pre-built Dawn Binaries (macOS ARM64)

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/README.html

Downloads and installs pre-built Dawn binaries for macOS ARM64. Sets the DAWN_INSTALL_DIR environment variable.

```bash
cd "${VTK_SOURCE_DIR}"
CMAKE_CONFIGURATION="macos_arm64" cmake -P .gitlab/ci/download_dawn.cmake
export DAWN_INSTALL_DIR="${VTK_SOURCE_DIR}/.gitlab/dawn"
```

--------------------------------

### Install Linux Build Dependencies

Source: https://docs.vtk.org/en/latest/build_instructions/build.html

Installs essential build tools and libraries for VTK on Ubuntu/Debian systems using apt.

```bash
sudo apt install \
build-essential \
cmake \
cmake-curses-gui \
mesa-common-dev \
mesa-utils \
freeglut3-dev \
ninja-build

```

--------------------------------

### Run TestOpenXRRemotingInitialization

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/OpenXRRemoting/README.html

Execute the OpenXR Remoting initialization test by providing the player's IP address as an argument. Ensure the OpenXR Remoting binary directory is in the system PATH.

```bash
vtkRenderingOpenXRRemotingCxxTests.exe "TestOpenXRRemotingInitialization" -playerIP XX.XX.XX.XX
```

--------------------------------

### Build Sphinx Documentation

Source: https://docs.vtk.org/en/latest/advanced/build_documentation.html

Builds the user and developer guides as HTML pages using Sphinx.

```bash
make html

```

--------------------------------

### Install a VTK Module Target

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModule.html

Installs a target within the module context. This is generally used by wrapping code or modules that cannot use `vtk_module_add_module()` directly.

```cmake
_vtk_module_install(<target>)
```

--------------------------------

### Example vtk.kit File Structure

Source: https://docs.vtk.org/en/latest/api/cmake/vtkModule.html

This snippet shows the basic structure of a vtk.kit file, including the NAME, LIBRARY_NAME, and DESCRIPTION fields.

```cmake
NAME
  VTK::Common
LIBRARY_NAME
  vtkCommon
DESCRIPTION
  Core utilities for VTK.


```

--------------------------------

### Configure and Build VTK with WebGPU (Linux/macOS)

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/README.html

Configures and builds VTK with WebGPU support on Linux or macOS, specifying the Dawn installation directory. Testing is enabled.

```bash
cmake \
-S "${VTK_SOURCE_DIR}" \
-B "${VTK_BUILD_DIR}" \
-GNinja \
-DVTK_ENABLE_WEBGPU=ON \
-DDawn_DIR="${DAWN_INSTALL_DIR}/lib/cmake/Dawn" \
-DVTK_BUILD_TESTING=ON

cmake --build "${VTK_BUILD_DIR}"
```

--------------------------------

### Fetch Pre-built Dawn Binaries (macOS x86_64)

Source: https://docs.vtk.org/en/latest/modules/vtk-modules/Rendering/WebGPU/README.html

Downloads and installs pre-built Dawn binaries for macOS x86_64. Sets the DAWN_INSTALL_DIR environment variable.

```bash
cd "${VTK_SOURCE_DIR}"
CMAKE_CONFIGURATION="macos_x86_64" cmake -P .gitlab/ci/download_dawn.cmake
export DAWN_INSTALL_DIR="${VTK_SOURCE_DIR}/.gitlab/dawn"
```
Tokens:
Raw