ViennaPS 4.1.0__cp312-cp312-musllinux_1_1_x86_64.whl

viennaps.libs/cmake/vtk-9.3/vtk-config-version.cmake

@@ -0,0 +1,43 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+set(PACKAGE_VERSION "9.3.1")
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+else()
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

viennaps.libs/cmake/vtk-9.3/vtk-config.cmake

@@ -0,0 +1,380 @@
+#[==[.md
+# vtk-config.cmake
+
+This file is used by CMake when finding VTK. It provides the [VTK module
+API][] as well as some VTK-specific APIs.
+
+The following variables are provided by this module:
+
+  * `VTK_VERSION`: The version of VTK found.
+  * `VTK_MAJOR_VERSION`: The major version of VTK found.
+  * `VTK_MINOR_VERSION`: The minor version of VTK found.
+  * `VTK_BUILD_VERSION`: The build version of VTK found.
+  * `VTK_AVAILABLE_COMPONENTS`: Components available with VTK.
+  * `VTK_PREFIX_PATH`: Install prefix for VTK.
+  * `VTK_LEGACY_REMOVE`: Whether VTK's deprecated APIs are
+    compiled out or not.
+  * `VTK_HAS_VTKm`: If VTK provides VTK-m.
+  * `VTK_OPENGL_HAS_EGL`: If VTK::opengl uses EGL. Only provided if the
+    `VTK::opengl` target exists.
+  * `VTK_PYTHON_VERSION`: The major version of Python used by VTK. Empty if
+    Python support is not available.
+  * `VTK_WRAP_PYTHON`: If VTK itself provides Python wrapping. If so, the
+    Python parts of the module API are available.
+  * `VTK_WRAP_JAVA`: If VTK itself provides Java wrapping. If so, the
+    Java parts of the module API are available.
+  * `VTK_PYTHONPATH`: Where VTK's Python modules live inside the install
+    prefix. Unset if Python is not available.
+  * `VTK_LIBRARIES`: The list of modules specified by `COMPONENTS` and
+    `OPTIONAL_COMPONENTS`. However, if no components are specified, all
+    available components are added to this variable. This may be used in
+    `MODULES` arguments in the API (e.g., `vtk_module_autoinit`). All modules
+    are also targets and may be linked to using `target_link_libraries`.
+  * `VTK_AUTOINIT_INCLUDE`: The header to include for access to VTK's autoinit
+    support.
+  * `VTK_QT_VERSION`: The major version of Qt used by VTK if Qt support enabled.
+  * `VTK_QML_DIR`: Where VTK's QML plugins live if QML support is enabled.
+  * `VTK_ENABLE_VR_COLLABORATION`: Is VR collaboration enabled when VR is enabled.
+  * `VTK_SMP_BACKENDS`: The list of available SMP backends.
+
+For more information about the Python in use by VTK, (note that the `Python`
+component must be found to guarantee that this happens), see the
+[FindPython3][] documentation for what is available. Of particular use are
+likely to be:
+
+  - the `Python3_VERSION` variable; and
+  - the `Python3::Python` target.
+
+[FindPython3]: https://cmake.org/cmake/help/v3.13/module/FindPython3.html
+[VTK module API]: TODO: Link to hosted documentation.
+#]==]
+
+if (CMAKE_VERSION VERSION_LESS "3.12")
+  set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 0)
+  set("${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE"
+    "VTK requires CMake 3.12 in order to reliably be used.")
+  return ()
+endif ()
+
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.12)
+
+set("${CMAKE_FIND_PACKAGE_NAME}_AVAILABLE_COMPONENTS" "loguru;IOVeraOut;hdf5;IOTecplotTable;vtksys;utf8;IOSegY;IOParallelXML;IOPLY;IOOggTheora;theora;ogg;IOLSDyna;IOIOSS;fmt;ioss;cgns;exodusII;zlib;IOFLUENTCFF;IOVideo;IOMovie;IOExodus;netcdf;IOEnSight;IOCityGML;pugixml;IOCellGrid;nlohmannjson;IOCONVERGECFD;IOHDF;IOCGNSReader;IOAsynchronous;IOAMR;ImagingStencil;ImagingStatistics;ImagingMorphological;ImagingMath;ImagingFourier;IOSQL;sqlite;ImagingHybrid;ImagingColor;FiltersTopology;FiltersTensor;FiltersSelection;FiltersSMP;FiltersReduction;FiltersProgrammable;FiltersPoints;FiltersImaging;ImagingGeneral;FiltersGeometryPreview;FiltersGeneric;FiltersFlowPaths;eigen;FiltersCellGrid;FiltersAMR;FiltersTexture;FiltersModeling;FiltersExtraction;ParallelDIY;diy2;IOXML;IOXMLParser;expat;ParallelCore;IOLegacy;IOCore;doubleconversion;lz4;lzma;fast_float;FiltersStatistics;FiltersHyperTree;ImagingSources;IOImage;DICOMParser;jpeg;metaio;png;tiff;FiltersSources;ImagingCore;FiltersGeneral;FiltersVerdict;verdict;FiltersGeometry;CommonComputationalGeometry;FiltersCore;CommonExecutionModel;CommonDataModel;CommonSystem;CommonMisc;exprtk;CommonTransforms;CommonMath;kissfft;CommonCore;kwiml")
+
+set(_vtk_temp_variables)
+set(_vtk_real_components)
+foreach (_vtk_component IN LISTS "${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS")
+  # Handle component requests that are not VTK.
+  if (NOT _vtk_component IN_LIST "${CMAKE_FIND_PACKAGE_NAME}_AVAILABLE_COMPONENTS")
+    set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 0)
+    list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_NOT_FOUND_MESSAGE"
+      "The ${_vtk_component} component is not recognized.")
+  endif ()
+  if (_vtk_component MATCHES "^vtk" AND
+      NOT _vtk_component STREQUAL "vtksys" AND
+      NOT _vtk_component STREQUAL "vtkjava")
+    string(SUBSTRING "${_vtk_component}" 3 -1 _vtk_actual_component)
+    if (NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION)
+      if (NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+        message(DEPRECATION
+          "The new name for the '${_vtk_component}' component is "
+          "'${_vtk_actual_component}'")
+      endif ()
+    elseif (${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION VERSION_LESS "8.90")
+      # Ignore for compatibility.
+    else ()
+      message(FATAL_ERROR
+        "The new name for the '${_vtk_component}' component is "
+        "'${_vtk_actual_component}'. By requesting at least version 8.90, the "
+        "new component names are now required.")
+    endif ()
+    list(APPEND _vtk_real_components
+      "${_vtk_actual_component}")
+    list(APPEND _vtk_temp_variables
+      "${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${_vtk_actual_component}")
+    set("${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${_vtk_actual_component}"
+      "${${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${_vtk_component}}")
+    unset(_vtk_actual_component)
+  else ()
+    list(APPEND _vtk_real_components
+      "${_vtk_component}")
+  endif ()
+endforeach ()
+unset(_vtk_component)
+set("${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS"
+  ${_vtk_real_components})
+unset(_vtk_real_components)
+
+set("${CMAKE_FIND_PACKAGE_NAME}_CMAKE_MODULE_PATH_save" "${CMAKE_MODULE_PATH}")
+list(INSERT CMAKE_MODULE_PATH 0
+  "${CMAKE_CURRENT_LIST_DIR}")
+
+set("${CMAKE_FIND_PACKAGE_NAME}_CMAKE_PREFIX_PATH_save" "${CMAKE_PREFIX_PATH}")
+include("${CMAKE_CURRENT_LIST_DIR}/vtk-prefix.cmake")
+set("${CMAKE_FIND_PACKAGE_NAME}_PREFIX_PATH"
+  "${_vtk_module_import_prefix}")
+unset(_vtk_module_import_prefix)
+list(INSERT CMAKE_PREFIX_PATH 0
+  "${${CMAKE_FIND_PACKAGE_NAME}_PREFIX_PATH}")
+
+set("${CMAKE_FIND_PACKAGE_NAME}_VERSION" "9.3.1")
+set("${CMAKE_FIND_PACKAGE_NAME}_MAJOR_VERSION" "9")
+set("${CMAKE_FIND_PACKAGE_NAME}_MINOR_VERSION" "3")
+set("${CMAKE_FIND_PACKAGE_NAME}_BUILD_VERSION" "1")
+set("${CMAKE_FIND_PACKAGE_NAME}_LEGACY_REMOVE" "ON")
+set("${CMAKE_FIND_PACKAGE_NAME}_AUTOINIT_INCLUDE" "\"vtkAutoInit.h\"")
+set("${CMAKE_FIND_PACKAGE_NAME}_SMP_BACKENDS" "STDThread;Sequential")
+
+unset("${CMAKE_FIND_PACKAGE_NAME}_FOUND")
+set("${CMAKE_FIND_PACKAGE_NAME}_HAS_VTKm" "OFF")
+if (${CMAKE_FIND_PACKAGE_NAME}_HAS_VTKm)
+  find_package(VTKm
+    PATHS "${CMAKE_CURRENT_LIST_DIR}/vtkm"
+    NO_DEFAULT_PATH)
+  if (NOT VTKm_FOUND)
+    set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 0)
+  endif ()
+
+  # Prior to VTK-m 2.0, the main VTK module was called VTK::vtkm
+  if (TARGET VTK::vtkvtkm)
+    add_library(VTK::vtkm ALIAS VTK::vtkvtkm)
+  endif()
+endif ()
+
+include("${CMAKE_CURRENT_LIST_DIR}/vtkCMakeBackports.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/${CMAKE_FIND_PACKAGE_NAME}-targets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/${CMAKE_FIND_PACKAGE_NAME}-vtk-module-properties.cmake")
+
+include("${CMAKE_CURRENT_LIST_DIR}/vtk-find-package-helpers.cmake" OPTIONAL)
+
+# Ensure that the right OpenGL preference is in place when finding the OpenGL
+# libraries.
+if (0) # vtk_opengl_preference_set
+  if (DEFINED OpenGL_GL_PREFERENCE)
+    set("${CMAKE_FIND_PACKAGE_NAME}_OpenGL_GL_PREFERENCE_save" "${OpenGL_GL_PREFERENCE}")
+  endif ()
+  set(OpenGL_GL_PREFERENCE "")
+endif ()
+
+# Ensure that python is found based on location, not on version
+# See https://cmake.org/cmake/help/latest/module/FindPython.html
+if (DEFINED Python3_FIND_STRATEGY)
+  set("${CMAKE_FIND_PACKAGE_NAME}_Python3_FIND_STRATEGY_save" "${Python3_FIND_STRATEGY}")
+endif ()
+set(Python3_FIND_STRATEGY LOCATION)
+
+include("${CMAKE_CURRENT_LIST_DIR}/${CMAKE_FIND_PACKAGE_NAME}-vtk-module-find-packages.cmake")
+
+if (0) # vtk_opengl_preference_set
+  if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_OpenGL_GL_PREFERENCE_save")
+    set(OpenGL_GL_PREFERENCE "${${CMAKE_FIND_PACKAGE_NAME}_OpenGL_GL_PREFERENCE_save}")
+    unset("${CMAKE_FIND_PACKAGE_NAME}_OpenGL_GL_PREFERENCE_save")
+  else ()
+    unset(OpenGL_GL_PREFERENCE)
+  endif ()
+endif ()
+
+if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_Python3_FIND_STRATEGY_save")
+  set(Python3_FIND_STRATEGY "${${CMAKE_FIND_PACKAGE_NAME}_Python3_FIND_STRATEGY_save}")
+  unset("${CMAKE_FIND_PACKAGE_NAME}_Python3_FIND_STRATEGY_save")
+else ()
+  unset(Python3_FIND_STRATEGY)
+endif ()
+
+if (TARGET VTK::opengl)
+  set(VTK_OPENGL_HAS_EGL "")
+endif ()
+
+if (TARGET VTK::RenderingVR)
+  set("${CMAKE_FIND_PACKAGE_NAME}_ENABLE_VR_COLLABORATION" "")
+endif ()
+
+if () # VTK_QT_VERSION
+  set("${CMAKE_FIND_PACKAGE_NAME}_QT_VERSION" "")
+endif ()
+
+if (0) # vtk_has_qml
+  set("${CMAKE_FIND_PACKAGE_NAME}_QML_DIR" "${${CMAKE_FIND_PACKAGE_NAME}_PREFIX_PATH}/lib/qml")
+endif ()
+
+include("${CMAKE_CURRENT_LIST_DIR}/vtkModule.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/vtkEncodeString.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/vtkHashSource.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/vtkObjectFactory.cmake")
+
+include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleJson.cmake")
+
+set("${CMAKE_FIND_PACKAGE_NAME}_PYTHON_VERSION" "")
+set("${CMAKE_FIND_PACKAGE_NAME}_WRAP_PYTHON" "OFF")
+if (${CMAKE_FIND_PACKAGE_NAME}_WRAP_PYTHON)
+  include("${CMAKE_CURRENT_LIST_DIR}/VTKPython-targets.cmake")
+  include("${CMAKE_CURRENT_LIST_DIR}/vtkmodules-vtk-python-module-properties.cmake")
+  include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleWrapPython.cmake")
+  set("${CMAKE_FIND_PACKAGE_NAME}_PYTHONPATH" "")
+endif ()
+
+set("${CMAKE_FIND_PACKAGE_NAME}_WRAP_JAVA" "OFF")
+if (${CMAKE_FIND_PACKAGE_NAME}_WRAP_JAVA)
+  include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleWrapJava.cmake")
+
+  if () # VTK_JAVA_JOGL_COMPONENT
+    set(_vtk_find_jogl_args)
+    if (${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+      list(APPEND _vtk_find_jogl_args QUIET)
+    endif ()
+    find_package(JOGL ${_vtk_find_jogl_args})
+    unset(_vtk_find_jogl_args)
+
+    if (JOGL_FOUND)
+      include("${CMAKE_CURRENT_LIST_DIR}/VTKJava-targets.cmake")
+      set("${CMAKE_FIND_PACKAGE_NAME}_vtkjava_FOUND" 1)
+    else ()
+      set("${CMAKE_FIND_PACKAGE_NAME}_vtkjava_FOUND" 0)
+      set("${CMAKE_FIND_PACKAGE_NAME}_vtkjava_NOT_FOUND_MESSAGE"
+        "JOGL was not found")
+    endif ()
+  endif ()
+endif ()
+
+set(_vtk_components_to_check)
+foreach (_vtk_component IN LISTS "${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS")
+  if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND")
+    # It was already not-found (likely due to `find-package` failures).
+  elseif (TARGET "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}")
+    list(APPEND _vtk_components_to_check
+      "${_vtk_component}")
+  else ()
+    set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 0)
+    list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_NOT_FOUND_MESSAGE"
+      "The ${_vtk_component} component is not available.")
+  endif ()
+endforeach ()
+unset(_vtk_component)
+
+while (_vtk_components_to_check)
+  list(GET _vtk_components_to_check 0 _vtk_component)
+  list(REMOVE_AT _vtk_components_to_check 0)
+  if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND")
+    # We've already made a determiniation.
+    continue ()
+  endif ()
+
+  get_property(_vtk_public_dependencies
+    TARGET    "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}"
+    PROPERTY  "INTERFACE_vtk_module_depends")
+  get_property(_vtk_private_dependencies
+    TARGET    "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}"
+    PROPERTY  "INTERFACE_vtk_module_private_depends")
+  get_property(_vtk_optional_dependencies
+    TARGET    "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}"
+    PROPERTY  "INTERFACE_vtk_module_optional_depends")
+  set(_vtk_dependencies
+    ${_vtk_public_dependencies}
+    ${_vtk_private_dependencies})
+  foreach (_vtk_optional_dependency IN LISTS _vtk_optional_dependencies)
+    if (TARGET "${_vtk_optional_dependency}")
+      list(APPEND _vtk_dependencies
+        "${_vtk_optional_dependency}")
+    endif ()
+  endforeach ()
+  unset(_vtk_public_dependencies)
+  unset(_vtk_private_dependencies)
+  unset(_vtk_optional_dependency)
+  unset(_vtk_optional_dependencies)
+
+  string(REPLACE "${CMAKE_FIND_PACKAGE_NAME}::" "" _vtk_dependencies "${_vtk_dependencies}")
+  set(_vtk_all_dependencies_checked TRUE)
+  foreach (_vtk_dependency IN LISTS _vtk_dependencies)
+    if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_dependency}_FOUND")
+      if (NOT ${CMAKE_FIND_PACKAGE_NAME}_${_vtk_dependency}_FOUND)
+        set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 0)
+        list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_NOT_FOUND_MESSAGE"
+          "Failed to find the ${_vtk_dependency} component.")
+      endif ()
+    else ()
+      # Check its dependencies.
+      list(APPEND _vtk_components_to_check
+        "${_vtk_dependency}")
+      set(_vtk_all_found FALSE)
+    endif ()
+  endforeach ()
+  if (NOT DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND")
+    if (_vtk_all_dependencies_checked)
+      set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 1)
+    else ()
+      list(APPEND _vtk_components_to_check
+        "${_vtk_component}")
+    endif ()
+  endif ()
+  unset(_vtk_all_dependencies_checked)
+  unset(_vtk_dependency)
+  unset(_vtk_dependencies)
+endwhile ()
+unset(_vtk_component)
+unset(_vtk_components_to_check)
+
+set(_vtk_missing_components)
+foreach (_vtk_component IN LISTS "${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS")
+  if (NOT ${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND AND ${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${_vtk_component})
+    list(APPEND _vtk_missing_components
+      "${_vtk_component}")
+  endif ()
+endforeach ()
+
+if (_vtk_missing_components)
+  list(REMOVE_DUPLICATES _vtk_missing_components)
+  list(SORT _vtk_missing_components)
+  string(REPLACE ";" ", " _vtk_missing_components "${_vtk_missing_components}")
+  set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 0)
+  set("${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE"
+    "Could not find the ${CMAKE_FIND_PACKAGE_NAME} package with the following required components: ${_vtk_missing_components}.")
+endif ()
+unset(_vtk_missing_components)
+
+set("${CMAKE_FIND_PACKAGE_NAME}_LIBRARIES")
+if (NOT DEFINED "${CMAKE_FIND_PACKAGE_NAME}_FOUND")
+  # If nothing went wrong, we've successfully found the package.
+  set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 1)
+  set(_vtk_found_components
+    ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
+  if (NOT _vtk_found_components)
+    set(_vtk_found_components
+      ${${CMAKE_FIND_PACKAGE_NAME}_AVAILABLE_COMPONENTS})
+  endif ()
+  list(REMOVE_ITEM _vtk_found_components
+    # These components need to always be requested explicitly since they are
+    # not modules.
+    WrapHierarchy;vtkpython;pvtkpython;WrapPython;WrapPythonInit;vtkjava;ParseJava;WrapJava)
+  # Build the `_LIBRARIES` variable.
+  foreach (_vtk_component IN LISTS _vtk_found_components)
+    if (TARGET "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}")
+      list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_LIBRARIES"
+        "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}")
+    endif ()
+  endforeach ()
+  unset(_vtk_component)
+  unset(_vtk_found_components)
+endif ()
+
+set(CMAKE_PREFIX_PATH "${${CMAKE_FIND_PACKAGE_NAME}_CMAKE_PREFIX_PATH_save}")
+unset("${CMAKE_FIND_PACKAGE_NAME}_CMAKE_PREFIX_PATH_save")
+
+set(CMAKE_MODULE_PATH "${${CMAKE_FIND_PACKAGE_NAME}_CMAKE_MODULE_PATH_save}")
+unset("${CMAKE_FIND_PACKAGE_NAME}_CMAKE_MODULE_PATH_save")
+
+foreach (_vtk_temp_variable IN LISTS _vtk_temp_variables)
+  unset("${_vtk_temp_variable}")
+endforeach ()
+unset(_vtk_temp_variable)
+unset(_vtk_temp_variables)
+
+# Compatibility with old code.
+if (NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION)
+  set(VTK_USE_FILE "${CMAKE_CURRENT_LIST_DIR}/vtk-use-file-deprecated.cmake")
+elseif (${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION VERSION_LESS "8.90")
+  set(VTK_USE_FILE "${CMAKE_CURRENT_LIST_DIR}/vtk-use-file-compat.cmake")
+else ()
+  set(VTK_USE_FILE "${CMAKE_CURRENT_LIST_DIR}/vtk-use-file-error.cmake")
+endif ()
+
+cmake_policy(POP)

viennaps.libs/cmake/vtk-9.3/vtk-prefix.cmake

@@ -0,0 +1,4 @@
+set(_vtk_module_import_prefix "${CMAKE_CURRENT_LIST_DIR}")
+get_filename_component(_vtk_module_import_prefix "${_vtk_module_import_prefix}" DIRECTORY)
+get_filename_component(_vtk_module_import_prefix "${_vtk_module_import_prefix}" DIRECTORY)
+get_filename_component(_vtk_module_import_prefix "${_vtk_module_import_prefix}" DIRECTORY)

viennaps.libs/cmake/vtk-9.3/vtk-use-file-compat.cmake

@@ -0,0 +1 @@
+# Nothing to do.

viennaps.libs/cmake/vtk-9.3/vtk-use-file-deprecated.cmake

@@ -0,0 +1,2 @@
+message(DEPRECATION
+  "The `VTK_USE_FILE` is no longer used starting with 8.90.")

viennaps.libs/cmake/vtk-9.3/vtk-use-file-error.cmake

@@ -0,0 +1,4 @@
+message(FATAL_ERROR
+  "The `VTK_USE_FILE` is no longer used starting with 8.90. The "
+  "`include(\${VTK_USE_FILE})` line is no longer necessary and can just be "
+  "removed.")

viennaps.libs/cmake/vtk-9.3/vtkCMakeBackports.cmake

@@ -0,0 +1,13 @@
+file(GLOB cmake_version_backports
+  LIST_DIRECTORIES true
+  RELATIVE "${CMAKE_CURRENT_LIST_DIR}/patches"
+  "${CMAKE_CURRENT_LIST_DIR}/patches/*")
+
+foreach (cmake_version_backport IN LISTS cmake_version_backports)
+  if (NOT IS_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/patches/${cmake_version_backport}")
+    continue ()
+  endif ()
+  if (CMAKE_VERSION VERSION_LESS "${cmake_version_backport}")
+    list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_LIST_DIR}/patches/${cmake_version_backport}")
+  endif ()
+endforeach ()

viennaps.libs/cmake/vtk-9.3/vtkDetectLibraryType.cmake

@@ -0,0 +1,136 @@
+#[==[
+@brief Detect library type of a library
+
+Sometimes it needs to be known whether a library is shared or static on a
+system in order to change the usage requirements of an imported target
+representing that library. This commonly occurs between static and shared
+builds that share a set of installed headers. This function returns one of
+`SHARED`, `STATIC`, or `UNKNOWN` into the variable passed as the first
+argument.
+
+~~~
+vtk_detect_library_type(<variable>
+  PATH <path>)
+~~~
+#]==]
+function (vtk_detect_library_type output)
+  cmake_parse_arguments(PARSE_ARGV 1 vdlt
+    ""
+    "PATH"
+    "")
+
+  if (NOT DEFINED vdlt_PATH)
+    message(FATAL_ERROR
+      "The `PATH` argument is required.")
+  endif ()
+
+  if (DEFINED vdlt_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "Unparsed arguments for vtk_detect_library_type: "
+      "${vdlt_UNPARSED_ARGUMENTS}")
+  endif ()
+
+  if (NOT vdlt_PATH)
+    message(FATAL_ERROR
+      "The `PATH` argument is empty.")
+  endif ()
+
+  set(vdlt_type UNKNOWN)
+  # Windows libraries all end with `.lib`. We need to detect the type based on
+  # the contents of the library. However, MinGW does use different extensions.
+  if (WIN32 AND NOT MINGW)
+    find_program(DUMPBIN_EXECUTABLE
+      NAMES dumpbin
+      DOC   "Path to the dumpbin executable")
+    mark_as_advanced(DUMPBIN_EXECUTABLE)
+    execute_process(
+      COMMAND "${DUMPBIN_EXECUTABLE}"
+              /HEADERS
+              "${vdlt_PATH}"
+      OUTPUT_VARIABLE vdlt_out
+      ERROR_VARIABLE  vdlt_err
+      RESULT_VARIABLE vdlt_res)
+    if (vdlt_res)
+      message(WARNING
+        "Failed to run `dumpbin` on ${vdlt_PATH}. Cannot determine "
+        "shared/static library type: ${vdlt_err}")
+    else ()
+      if (vdlt_out MATCHES "DLL name     :")
+        set(vdlt_type SHARED)
+      else ()
+        set(vdlt_type STATIC)
+      endif ()
+    endif ()
+  else ()
+    string(LENGTH "${vdlt_PATH}" vdlt_path_len)
+
+    string(LENGTH "${CMAKE_SHARED_LIBRARY_SUFFIX}" vdlt_shared_suffix_len)
+    math(EXPR vdlt_shared_idx "${vdlt_path_len} - ${vdlt_shared_suffix_len}")
+    string(SUBSTRING "${vdlt_PATH}" "${vdlt_shared_idx}" -1 vdlt_shared_check)
+
+    string(LENGTH "${CMAKE_STATIC_LIBRARY_SUFFIX}" vdlt_static_suffix_len)
+    math(EXPR vdlt_static_idx "${vdlt_path_len} - ${vdlt_static_suffix_len}")
+    string(SUBSTRING "${vdlt_PATH}" "${vdlt_static_idx}" -1 vdlt_static_check)
+
+    if (vdlt_shared_check STREQUAL CMAKE_SHARED_LIBRARY_SUFFIX)
+      set(vdlt_type SHARED)
+    elseif (vdlt_static_check STREQUAL CMAKE_STATIC_LIBRARY_SUFFIX)
+      set(vdlt_type STATIC)
+    endif ()
+
+    # when import suffix != static suffix, we can disambiguate static and import
+    if (WIN32 AND NOT CMAKE_IMPORT_LIBRARY_SUFFIX STREQUAL CMAKE_STATIC_LIBRARY_SUFFIX)
+      string(LENGTH "${CMAKE_IMPORT_LIBRARY_SUFFIX}" vdlt_import_suffix_len)
+      math(EXPR vdlt_import_idx "${vdlt_path_len} - ${vdlt_import_suffix_len}")
+      string(SUBSTRING "${vdlt_PATH}" "${vdlt_import_idx}" -1 vdlt_import_check)
+      if (vdlt_import_check STREQUAL CMAKE_IMPORT_LIBRARY_SUFFIX)
+        set(vdlt_type SHARED)
+      endif ()
+    endif ()
+  endif ()
+
+  set("${output}"
+    "${vdlt_type}"
+    PARENT_SCOPE)
+endfunction ()
+
+#[==[
+@brief Detect whether an imported target is shared or not
+
+This is intended for use with modules using
+[vtk_module_third_party_external](https://docs.vtk.org/en/latest/api/cmake/vtkModule.html#command:vtk_module_third_party_external)
+to detect whether that module is shared or
+not. Generally, this should be replaced with the `Find` module providing this
+information and modifying the usage requirements as necessary instead, but it
+is not always possible.
+
+~~~
+vtk_detect_library_shared(<name> <target>)
+~~~
+
+Sets `<name>_is_shared` in the caller's scope if `<target>` is a shared
+library. If it is an `UNKNOWN_LIBRARY`, a cache variable is exposed to allow
+the user to provide the information if it ends up breaking something.
+#]==]
+function (vtk_detect_library_shared name target)
+  if (VTK_MODULE_USE_EXTERNAL_${name})
+    get_property(library_type
+      TARGET    "${target}"
+      PROPERTY  TYPE)
+    if (library_type STREQUAL "SHARED_LIBRARY")
+      set(is_shared 1)
+    elseif (library_type STREQUAL "UNKNOWN_LIBRARY")
+      option("VTK_MODULE_${name}_IS_SHARED" "Whether the ${name} in use is shared or not" ON)
+      mark_as_advanced("VTK_MODULE_${name}_IS_SHARED")
+      set(is_shared "${VTK_MODULE_${name}_IS_SHARED}")
+    else ()
+      set(is_shared 0)
+    endif ()
+  else ()
+    set(is_shared "${BUILD_SHARED_LIBS}")
+  endif ()
+
+  set("${name}_is_shared"
+    "${is_shared}"
+    PARENT_SCOPE)
+endfunction ()