ViennaPS 3.0.1__cp311-cp311-macosx_11_0_arm64.whl

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

@@ -0,0 +1,282 @@
+# XXX: Copied from CMake, but includes vtkDetectLibraryType.
+# See https://gitlab.kitware.com/cmake/cmake/-/issues/18564
+
+#[=======================================================================[.rst:
+FindFreetype
+------------
+
+Find the FreeType font renderer includes and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :prop_tgt:`IMPORTED` target:
+
+``Freetype::Freetype``
+  The Freetype ``freetype`` library, if found
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``FREETYPE_FOUND``
+  true if the Freetype headers and libraries were found
+``FREETYPE_INCLUDE_DIRS``
+  directories containing the Freetype headers. This is the
+  concatenation of the variables:
+
+  ``FREETYPE_INCLUDE_DIR_ft2build``
+    directory holding the main Freetype API configuration header
+  ``FREETYPE_INCLUDE_DIR_freetype2``
+    directory holding Freetype public headers
+``FREETYPE_LIBRARIES``
+  the library to link against
+``FREETYPE_VERSION_STRING``
+  the version of freetype found (since CMake 2.8.8)
+
+Hints
+^^^^^
+
+The user may set the environment variable ``FREETYPE_DIR`` to the root
+directory of a Freetype installation.
+#]=======================================================================]
+
+# Created by Eric Wing.
+# Modifications by Alexander Neundorf.
+# This file has been renamed to "FindFreetype.cmake" instead of the correct
+# "FindFreeType.cmake" in order to be compatible with the one from KDE4, Alex.
+
+# Ugh, FreeType seems to use some #include trickery which
+# makes this harder than it should be. It looks like they
+# put ft2build.h in a common/easier-to-find location which
+# then contains a #include to a more specific header in a
+# more specific location (#include <freetype/config/ftheader.h>).
+# Then from there, they need to set a bunch of #define's
+# so you can do something like:
+# #include FT_FREETYPE_H
+# Unfortunately, using CMake's mechanisms like include_directories()
+# wants explicit full paths and this trickery doesn't work too well.
+# I'm going to attempt to cut out the middleman and hope
+# everything still works.
+
+set(_Freetype_args)
+if (Freetype_FIND_QUIETLY)
+  list(APPEND _Freetype_args
+    QUIET)
+endif ()
+if (Freetype_FIND_VERSION)
+  list(APPEND _Freetype_args
+    "${Freetype_FIND_VERSION}")
+  if (Freetype_FIND_VERSION_EXACT)
+    list(APPEND _Freetype_args
+      EXACT)
+  endif ()
+endif ()
+set(_Freetype_component_req)
+set(_Freetype_component_opt)
+foreach (_Freetype_component IN LISTS Freetype_FIND_COMPONENTS)
+  if (Freetype_FIND_REQUIRE_${_Freetype_component})
+    list(APPEND _Freetype_component_req
+      "${_Freetype_component}")
+  else ()
+    list(APPEND _Freetype_component_opt
+      "${_Freetype_component}")
+  endif ()
+endforeach ()
+unset(_Freetype_component)
+if (_Freetype_component_req)
+  list(APPEND _Freetype_args
+    COMPONENTS "${_Freetype_component_req}")
+endif ()
+unset(_Freetype_component_req)
+if (_Freetype_component_opt)
+  list(APPEND _Freetype_args
+    OPTIONAL_COMPONENTS "${_Freetype_component_opt}")
+endif ()
+unset(_Freetype_component_opt)
+find_package(freetype CONFIG ${_Freetype_args})
+unset(_Freetype_args)
+if (freetype_FOUND)
+  if (NOT TARGET Freetype::Freetype)
+    add_library(Freetype::Freetype IMPORTED INTERFACE)
+    set_target_properties(Freetype::Freetype PROPERTIES
+      INTERFACE_LINK_LIBRARIES freetype)
+  endif ()
+  get_property(FREETYPE_INCLUDE_DIRS TARGET freetype PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+  get_property(FREETYPE_LIBRARIES TARGET freetype PROPERTY INTERFACE_LINK_LIBRARIES)
+  get_property(_Freetype_location TARGET freetype PROPERTY LOCATION)
+  list(APPEND FREETYPE_LIBRARIES
+    "${_Freetype_location}")
+  unset(_Freetype_location)
+  set(Freetype_FOUND 1)
+  set(FREETYPE_VERSION_STRING "${freetype_VERSION}")
+  foreach (_Freetype_component IN LISTS Freetype_FIND_COMPONENTS)
+    set(Freetype_${_Freetype_component}_FOUND "${freetype_${_Freetype_component}_FOUND}")
+  endforeach ()
+  unset(_Freetype_component)
+  return ()
+endif ()
+
+set(FREETYPE_FIND_ARGS
+  HINTS
+    ENV FREETYPE_DIR
+  PATHS
+    ENV GTKMM_BASEPATH
+    [HKEY_CURRENT_USER\\SOFTWARE\\gtkmm\\2.4;Path]
+    [HKEY_LOCAL_MACHINE\\SOFTWARE\\gtkmm\\2.4;Path]
+)
+
+find_path(
+  FREETYPE_INCLUDE_DIR_ft2build
+  ft2build.h
+  ${FREETYPE_FIND_ARGS}
+  PATH_SUFFIXES
+    include/freetype2
+    include
+    freetype2
+)
+
+find_path(
+  FREETYPE_INCLUDE_DIR_freetype2
+  NAMES
+    freetype/config/ftheader.h
+    config/ftheader.h
+  ${FREETYPE_FIND_ARGS}
+  PATH_SUFFIXES
+    include/freetype2
+    include
+    freetype2
+)
+
+if(NOT FREETYPE_LIBRARY)
+  find_library(FREETYPE_LIBRARY_RELEASE
+    NAMES
+      freetype
+      libfreetype
+      freetype219
+    ${FREETYPE_FIND_ARGS}
+    PATH_SUFFIXES
+      lib
+  )
+  find_library(FREETYPE_LIBRARY_DEBUG
+    NAMES
+      freetyped
+      libfreetyped
+      freetype219d
+    ${FREETYPE_FIND_ARGS}
+    PATH_SUFFIXES
+      lib
+  )
+  include(SelectLibraryConfigurations)
+  select_library_configurations(FREETYPE)
+else()
+  # on Windows, ensure paths are in canonical format (forward slahes):
+  file(TO_CMAKE_PATH "${FREETYPE_LIBRARY}" FREETYPE_LIBRARY)
+endif()
+
+unset(FREETYPE_FIND_ARGS)
+
+# set the user variables
+if(FREETYPE_INCLUDE_DIR_ft2build AND FREETYPE_INCLUDE_DIR_freetype2)
+  set(FREETYPE_INCLUDE_DIRS "${FREETYPE_INCLUDE_DIR_ft2build};${FREETYPE_INCLUDE_DIR_freetype2}")
+  list(REMOVE_DUPLICATES FREETYPE_INCLUDE_DIRS)
+endif()
+set(FREETYPE_LIBRARIES "${FREETYPE_LIBRARY}")
+
+if(EXISTS "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/freetype.h")
+  set(FREETYPE_H "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/freetype.h")
+elseif(EXISTS "${FREETYPE_INCLUDE_DIR_freetype2}/freetype.h")
+  set(FREETYPE_H "${FREETYPE_INCLUDE_DIR_freetype2}/freetype.h")
+endif()
+
+if(FREETYPE_INCLUDE_DIR_freetype2 AND FREETYPE_H)
+  file(STRINGS "${FREETYPE_H}" freetype_version_str
+       REGEX "^#[\t ]*define[\t ]+FREETYPE_(MAJOR|MINOR|PATCH)[\t ]+[0-9]+$")
+
+  unset(FREETYPE_VERSION_STRING)
+  foreach(VPART MAJOR MINOR PATCH)
+    foreach(VLINE ${freetype_version_str})
+      if(VLINE MATCHES "^#[\t ]*define[\t ]+FREETYPE_${VPART}[\t ]+([0-9]+)$")
+        set(FREETYPE_VERSION_PART "${CMAKE_MATCH_1}")
+        if(FREETYPE_VERSION_STRING)
+          string(APPEND FREETYPE_VERSION_STRING ".${FREETYPE_VERSION_PART}")
+        else()
+          set(FREETYPE_VERSION_STRING "${FREETYPE_VERSION_PART}")
+        endif()
+        unset(FREETYPE_VERSION_PART)
+      endif()
+    endforeach()
+  endforeach()
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(
+  Freetype
+  REQUIRED_VARS
+    FREETYPE_LIBRARY
+    FREETYPE_INCLUDE_DIRS
+  VERSION_VAR
+    FREETYPE_VERSION_STRING
+)
+
+mark_as_advanced(
+  FREETYPE_INCLUDE_DIR_freetype2
+  FREETYPE_INCLUDE_DIR_ft2build
+)
+
+if(Freetype_FOUND)
+  if(NOT TARGET Freetype::Freetype)
+    include(vtkDetectLibraryType)
+    set(freetype_library_type UNKNOWN)
+    if (FREETYPE_LIBRARY_RELEASE)
+      vtk_detect_library_type(freetype_release_library_type
+        PATH "${FREETYPE_LIBRARY_RELEASE}")
+    endif ()
+    if (FREETYPE_LIBRARY_DEBUG)
+      vtk_detect_library_type(freetype_debug_library_type
+        PATH "${FREETYPE_LIBRARY_DEBUG}")
+    endif ()
+    if (freetype_release_library_type AND freetype_debug_library_type)
+      if (freetype_release_library_type STREQUAL freetype_debug_library_type)
+        set(freetype_library_type "${freetype_release_library_type}")
+      endif ()
+    elseif (freetype_release_library_type)
+      set(freetype_library_type "${freetype_release_library_type}")
+    elseif (freetype_debug_library_type)
+      set(freetype_library_type "${freetype_debug_library_type}")
+    endif ()
+    add_library(Freetype::Freetype "${freetype_library_type}" IMPORTED)
+    unset(freetype_release_library_type)
+    unset(freetype_debug_library_type)
+    unset(freetype_library_type)
+    set_target_properties(Freetype::Freetype PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${FREETYPE_INCLUDE_DIRS}")
+
+    if(FREETYPE_LIBRARY_RELEASE)
+      set_property(TARGET Freetype::Freetype APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(Freetype::Freetype PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
+        IMPORTED_LOCATION_RELEASE "${FREETYPE_LIBRARY_RELEASE}"
+        IMPORTED_IMPLIB_RELEASE "${FREETYPE_LIBRARY_RELEASE}")
+    endif()
+
+    if(FREETYPE_LIBRARY_DEBUG)
+      set_property(TARGET Freetype::Freetype APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(Freetype::Freetype PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
+        IMPORTED_LOCATION_DEBUG "${FREETYPE_LIBRARY_DEBUG}"
+        IMPORTED_IMPLIB_DEBUG "${FREETYPE_LIBRARY_DEBUG}")
+    endif()
+
+    if(NOT FREETYPE_LIBRARY_RELEASE AND NOT FREETYPE_LIBRARY_DEBUG)
+      set_target_properties(Freetype::Freetype PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+        IMPORTED_LOCATION "${FREETYPE_LIBRARY}"
+        IMPORTED_IMPLIB "${FREETYPE_LIBRARY}")
+    endif()
+  endif()
+endif()

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

@@ -0,0 +1,38 @@
+find_path(GL2PS_INCLUDE_DIR
+  NAMES gl2ps.h
+  DOC "gl2ps include directories")
+mark_as_advanced(GL2PS_INCLUDE_DIR)
+
+find_library(GL2PS_LIBRARY
+  NAMES gl2ps
+  DOC "gl2ps library")
+mark_as_advanced(GL2PS_LIBRARY)
+
+if (GL2PS_INCLUDE_DIR)
+  file(STRINGS "${GL2PS_INCLUDE_DIR}/gl2ps.h" _gl2ps_version_lines REGEX "#define[ \t]+GL2PS_(MAJOR|MINOR|PATCH)_VERSION[ \t]+")
+  string(REGEX REPLACE ".*GL2PS_MAJOR_VERSION *\([0-9]*\).*" "\\1" _gl2ps_version_major "${_gl2ps_version_lines}")
+  string(REGEX REPLACE ".*GL2PS_MINOR_VERSION *\([0-9]*\).*" "\\1" _gl2ps_version_minor "${_gl2ps_version_lines}")
+  string(REGEX REPLACE ".*GL2PS_PATCH_VERSION *\([0-9]*\).*" "\\1" _gl2ps_version_patch "${_gl2ps_version_lines}")
+  set(GL2PS_VERSION "${_gl2ps_version_major}.${_gl2ps_version_minor}.${_gl2ps_version_patch}")
+  unset(_gl2ps_version_major)
+  unset(_gl2ps_version_minor)
+  unset(_gl2ps_version_patch)
+  unset(_gl2ps_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GL2PS
+  REQUIRED_VARS GL2PS_LIBRARY GL2PS_INCLUDE_DIR
+  VERSION_VAR GL2PS_VERSION)
+
+if (GL2PS_FOUND)
+  set(GL2PS_INCLUDE_DIRS "${GL2PS_INCLUDE_DIR}")
+  set(GL2PS_LIBRARIES "${GL2PS_LIBRARY}")
+
+  if (NOT TARGET GL2PS::GL2PS)
+    add_library(GL2PS::GL2PS UNKNOWN IMPORTED)
+    set_target_properties(GL2PS::GL2PS PROPERTIES
+      IMPORTED_LOCATION "${GL2PS_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${GL2PS_INCLUDE_DIR}")
+  endif ()
+endif ()

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

@@ -0,0 +1,28 @@
+find_path(GLEW_INCLUDE_DIR
+  NAMES GL/glew.h
+  DOC "glew include directory")
+mark_as_advanced(GLEW_INCLUDE_DIR)
+find_library(GLEW_LIBRARY
+  NAMES GLEW glew32
+  DOC "glew library")
+mark_as_advanced(GLEW_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GLEW REQUIRED_VARS GLEW_LIBRARY GLEW_INCLUDE_DIR)
+
+if (GLEW_FOUND)
+  set(GLEW_INCLUDE_DIRS "${GLEW_INCLUDE_DIR}")
+  set(GLEW_LIBRARIES "${GLEW_LIBRARY}")
+
+  if (NOT TARGET GLEW::GLEW)
+    include(vtkDetectLibraryType)
+    vtk_detect_library_type(glew_library_type
+      PATH "${GLEW_LIBRARY}")
+    add_library(GLEW::GLEW "${glew_library_type}" IMPORTED)
+    unset(glew_library_type)
+    set_target_properties(GLEW::GLEW PROPERTIES
+      IMPORTED_LOCATION "${GLEW_LIBRARY}"
+      IMPORTED_IMPLIB "${GLEW_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIR}")
+  endif ()
+endif ()

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

@@ -0,0 +1,64 @@
+if (COMMAND "find_jar")
+  set(_jogl_versions
+    ${JOGL_EXTRA_VERSIONS} 2.3.2)
+
+  set(_JOGL_Java_JAR_PATHS)
+  if (DEFINED Java_JAR_PATHS)
+    set(_JOGL_Java_JAR_PATHS "${Java_JAR_PATHS}")
+  endif ()
+
+  foreach (_JOGL_prefix IN ITEMS "${CMAKE_INSTALL_PREFIX}" /usr/local /usr)
+    foreach (_JOGL_libdir IN ITEMS "${CMAKE_INSTALL_LIBDIR}" lib64 lib)
+      list(APPEND Java_JAR_PATHS
+        "${_JOGL_prefix}/${_JOGL_libdir}/java"
+        "${_JOGL_prefix}/${_JOGL_libdir}")
+    endforeach ()
+  endforeach ()
+  list(REMOVE_DUPLICATES Java_JAR_PATHS)
+  unset(_JOGL_libdir)
+  unset(_JOGL_prefix)
+
+  find_jar(JOGL_LIB
+    NAMES jogl-all jogl2
+    PATHS # Abuse the argument parser in `find_jar`
+    PATH_SUFFIXES jogl2
+    VERSIONS ${_jogl_versions}
+    DOC "Path to the JOGL jar")
+  mark_as_advanced(JOGL_LIB)
+
+  find_jar(JOGL_GLUE
+    NAMES gluegen-rt gluegen2-rt
+    VERSIONS ${_jogl_versions}
+    PATHS # Abuse the argument parser in `find_jar`
+    PATH_SUFFIXES gluegen2
+    DOC "Path to the JOGL gluegen jar")
+  mark_as_advanced(JOGL_GLUE)
+
+  set(Java_JAR_PATHS)
+  if (DEFINED _JOGL_Java_JAR_PATHS)
+    set(Java_JAR_PATHS "${_JOGL_Java_JAR_PATHS}")
+  endif ()
+  unset(_JOGL_Java_JAR_PATHS)
+
+  unset(_jogl_versions)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(JOGL
+  REQUIRED_VARS JOGL_LIB JOGL_GLUE)
+
+if (JOGL_FOUND)
+  if (NOT TARGET JOGL::glue)
+    add_library(JOGL::glue STATIC IMPORTED)
+    set_target_properties(JOGL::glue PROPERTIES
+      IMPORTED_LINK_INTERFACE_LANGUAGES Java
+      IMPORTED_LOCATION "${JOGL_GLUE}")
+  endif ()
+  if (NOT TARGET JOGL::JOGL)
+    add_library(JOGL::JOGL STATIC IMPORTED)
+    set_target_properties(JOGL::JOGL PROPERTIES
+      IMPORTED_LINK_INTERFACE_LANGUAGES Java
+      IMPORTED_LOCATION "${JOGL_LIB}"
+      INTERFACE_LINK_LIBRARIES "JOGL::glue")
+  endif ()
+endif ()

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

@@ -0,0 +1,44 @@
+find_path(JsonCpp_INCLUDE_DIR "json/json.h"
+  PATH_SUFFIXES "jsoncpp"
+  DOC "jsoncpp include directory")
+mark_as_advanced(JsonCpp_INCLUDE_DIR)
+
+find_library(JsonCpp_LIBRARY
+  NAMES jsoncpp
+  DOC "jsoncpp library")
+mark_as_advanced(JsonCpp_LIBRARY)
+
+if (JsonCpp_INCLUDE_DIR AND EXISTS "${JsonCpp_INCLUDE_DIR}/json/version.h")
+  file(STRINGS "${JsonCpp_INCLUDE_DIR}/json/version.h" _JsonCpp_version_lines
+    REGEX "JSONCPP_VERSION_[A-Z]+")
+  string(REGEX REPLACE ".*# *define +JSONCPP_VERSION_MAJOR +([0-9]+).*" "\\1" _JsonCpp_version_major "${_JsonCpp_version_lines}")
+  string(REGEX REPLACE ".*# *define +JSONCPP_VERSION_MINOR +([0-9]+).*" "\\1" _JsonCpp_version_minor "${_JsonCpp_version_lines}")
+  string(REGEX REPLACE ".*# *define +JSONCPP_VERSION_PATCH +([0-9]+).*" "\\1" _JsonCpp_version_patch "${_JsonCpp_version_lines}")
+  set(JsonCpp_VERSION "${_JsonCpp_version_major}.${_JsonCpp_version_minor}.${_JsonCpp_version_patch}")
+  unset(_JsonCpp_version_major)
+  unset(_JsonCpp_version_minor)
+  unset(_JsonCpp_version_patch)
+  unset(_JsonCpp_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(JsonCpp
+  REQUIRED_VARS JsonCpp_LIBRARY JsonCpp_INCLUDE_DIR
+  VERSION_VAR JsonCpp_VERSION)
+
+if (JsonCpp_FOUND)
+  set(JsonCpp_INCLUDE_DIRS "${JsonCpp_INCLUDE_DIR}")
+  set(JsonCpp_LIBRARIES "${JsonCpp_LIBRARY}")
+
+  if (NOT TARGET JsonCpp::JsonCpp)
+    include(vtkDetectLibraryType)
+    vtk_detect_library_type(jsoncpp_library_type
+      PATH "${JsonCpp_LIBRARY}")
+    add_library(JsonCpp::JsonCpp "${jsoncpp_library_type}" IMPORTED)
+    unset(jsoncpp_library_type)
+    set_target_properties(JsonCpp::JsonCpp PROPERTIES
+      IMPORTED_LOCATION "${JsonCpp_LIBRARY}"
+      IMPORTED_IMPLIB "${JsonCpp_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${JsonCpp_INCLUDE_DIR}")
+  endif ()
+endif ()

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

@@ -0,0 +1,38 @@
+find_path(LZ4_INCLUDE_DIR
+  NAMES lz4.h
+  DOC "lz4 include directory")
+mark_as_advanced(LZ4_INCLUDE_DIR)
+find_library(LZ4_LIBRARY
+  NAMES lz4 liblz4
+  DOC "lz4 library")
+mark_as_advanced(LZ4_LIBRARY)
+
+if (LZ4_INCLUDE_DIR)
+  file(STRINGS "${LZ4_INCLUDE_DIR}/lz4.h" _lz4_version_lines
+    REGEX "#define[ \t]+LZ4_VERSION_(MAJOR|MINOR|RELEASE)")
+  string(REGEX REPLACE ".*LZ4_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lz4_version_major "${_lz4_version_lines}")
+  string(REGEX REPLACE ".*LZ4_VERSION_MINOR *\([0-9]*\).*" "\\1" _lz4_version_minor "${_lz4_version_lines}")
+  string(REGEX REPLACE ".*LZ4_VERSION_RELEASE *\([0-9]*\).*" "\\1" _lz4_version_release "${_lz4_version_lines}")
+  set(LZ4_VERSION "${_lz4_version_major}.${_lz4_version_minor}.${_lz4_version_release}")
+  unset(_lz4_version_major)
+  unset(_lz4_version_minor)
+  unset(_lz4_version_release)
+  unset(_lz4_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LZ4
+  REQUIRED_VARS LZ4_LIBRARY LZ4_INCLUDE_DIR
+  VERSION_VAR LZ4_VERSION)
+
+if (LZ4_FOUND)
+  set(LZ4_INCLUDE_DIRS "${LZ4_INCLUDE_DIR}")
+  set(LZ4_LIBRARIES "${LZ4_LIBRARY}")
+
+  if (NOT TARGET LZ4::LZ4)
+    add_library(LZ4::LZ4 UNKNOWN IMPORTED)
+    set_target_properties(LZ4::LZ4 PROPERTIES
+      IMPORTED_LOCATION "${LZ4_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LZ4_INCLUDE_DIR}")
+  endif ()
+endif ()

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

@@ -0,0 +1,41 @@
+find_path(LZMA_INCLUDE_DIR
+  NAMES lzma.h
+  DOC "lzma include directory")
+find_library(LZMA_LIBRARY
+  NAMES lzma liblzma
+  DOC "lzma library")
+
+if (LZMA_INCLUDE_DIR)
+  file(STRINGS "${LZMA_INCLUDE_DIR}/lzma/version.h" _lzma_version_lines
+    REGEX "#define[ \t]+LZMA_VERSION_(MAJOR|MINOR|PATCH)")
+  string(REGEX REPLACE ".*LZMA_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lzma_version_major "${_lzma_version_lines}")
+  string(REGEX REPLACE ".*LZMA_VERSION_MINOR *\([0-9]*\).*" "\\1" _lzma_version_minor "${_lzma_version_lines}")
+  string(REGEX REPLACE ".*LZMA_VERSION_PATCH *\([0-9]*\).*" "\\1" _lzma_version_patch "${_lzma_version_lines}")
+  set(LZMA_VERSION "${_lzma_version_major}.${_lzma_version_minor}.${_lzma_version_patch}")
+  unset(_lzma_version_major)
+  unset(_lzma_version_minor)
+  unset(_lzma_version_patch)
+  unset(_lzma_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LZMA
+  REQUIRED_VARS LZMA_LIBRARY LZMA_INCLUDE_DIR
+  VERSION_VAR LZMA_VERSION)
+
+if (LZMA_FOUND)
+  set(LZMA_LIBRARIES "${LZMA_LIBRARY}")
+  set(LZMA_INCLUDE_DIRS "${LZMA_INCLUDE_DIR}")
+
+  if (NOT TARGET LZMA::LZMA)
+    include(vtkDetectLibraryType)
+    vtk_detect_library_type(lzma_library_type
+      PATH "${LZMA_LIBRARY}")
+    add_library(LZMA::LZMA "${lzma_library_type}" IMPORTED)
+    unset(lzma_library_type)
+    set_target_properties(LZMA::LZMA PROPERTIES
+      IMPORTED_LOCATION "${LZMA_LIBRARY}"
+      IMPORTED_IMPLIB "${LZMA_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LZMA_INCLUDE_DIR}")
+  endif ()
+endif ()

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

@@ -0,0 +1,87 @@
+find_path(LibHaru_INCLUDE_DIR
+  NAMES hpdf.h
+  DOC "libharu include directory")
+mark_as_advanced(LibHaru_INCLUDE_DIR)
+
+find_library(LibHaru_LIBRARY_RELEASE
+  NAMES hpdf hpdfs libhpdf libhpdfs
+  DOC "libharu release library")
+mark_as_advanced(LibHaru_LIBRARY_RELEASE)
+find_library(LibHaru_LIBRARY_DEBUG
+  NAMES hpdfd hpdfsd libhpdfd libhpdfsd
+  DOC "libharu debug library")
+mark_as_advanced(LibHaru_LIBRARY_DEBUG)
+
+if (LibHaru_INCLUDE_DIR)
+  file(STRINGS "${LibHaru_INCLUDE_DIR}/hpdf_version.h" _libharu_version_lines
+    REGEX "#define HPDF_(MAJOR|MINOR|BUGFIX|EXTRA)_VERSION")
+  string(REGEX REPLACE ".*HPDF_MAJOR_VERSION *\([0-9]*\).*" "\\1" _libharu_version_major "${_libharu_version_lines}")
+  string(REGEX REPLACE ".*HPDF_MINOR_VERSION *\([0-9]*\).*" "\\1" _libharu_version_minor "${_libharu_version_lines}")
+  string(REGEX REPLACE ".*HPDF_BUGFIX_VERSION *\([0-9]*\).*" "\\1" _libharu_version_bugfix "${_libharu_version_lines}")
+  string(REGEX REPLACE ".*HPDF_EXTRA_VERSION *\"\([^\"]*\)\".*" "\\1" _libharu_version_extra "${_libharu_version_lines}")
+  set(LibHaru_VERSION "${_libharu_version_major}.${_libharu_version_minor}.${_libharu_version_bugfix}")
+  if (_libharu_version_extra)
+    string(APPEND LibHaru_VERSION
+      "-${_libharu_version_extra}")
+  endif ()
+  unset(_libharu_version_major)
+  unset(_libharu_version_minor)
+  unset(_libharu_version_bugfix)
+  unset(_libharu_version_extra)
+  unset(_libharu_version_lines)
+endif ()
+
+include(SelectLibraryConfigurations)
+select_library_configurations(LibHaru)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LibHaru
+  REQUIRED_VARS LibHaru_LIBRARY LibHaru_INCLUDE_DIR
+  VERSION_VAR LibHaru_VERSION)
+
+if (LibHaru_FOUND)
+  set(LibHaru_INCLUDE_DIRS "${LibHaru_INCLUDE_DIR}")
+  set(LibHaru_LIBRARIES "${LibHaru_LIBRARY}")
+
+  if (NOT TARGET LibHaru::LibHaru)
+    include(vtkDetectLibraryType)
+    set(libharu_library_type UNKNOWN)
+    if (LibHaru_LIBRARY_RELEASE)
+      vtk_detect_library_type(libharu_release_library_type
+        PATH "${LibHaru_LIBRARY_RELEASE}")
+    endif ()
+    if (LibHaru_LIBRARY_DEBUG)
+      vtk_detect_library_type(libharu_debug_library_type
+        PATH "${LibHaru_LIBRARY_DEBUG}")
+    endif ()
+    if (libharu_release_library_type AND libharu_debug_library_type)
+      if (libharu_release_library_type STREQUAL libharu_debug_library_type)
+        set(libharu_library_type "${libharu_release_library_type}")
+      endif ()
+    elseif (libharu_release_library_type)
+      set(libharu_library_type "${libharu_release_library_type}")
+    elseif (libharu_debug_library_type)
+      set(libharu_library_type "${libharu_debug_library_type}")
+    endif ()
+    add_library(LibHaru::LibHaru "${libharu_library_type}" IMPORTED)
+    unset(libharu_release_library_type)
+    unset(libharu_debug_library_type)
+    unset(libharu_library_type)
+    set_target_properties(LibHaru::LibHaru PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${LibHaru_INCLUDE_DIR}")
+    if (LibHaru_LIBRARY_RELEASE)
+      set_property(TARGET LibHaru::LibHaru APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(LibHaru::LibHaru PROPERTIES
+        IMPORTED_LOCATION_RELEASE "${LibHaru_LIBRARY_RELEASE}"
+        IMPORTED_IMPLIB_RELEASE "${LibHaru_LIBRARY_RELEASE}")
+    endif ()
+    if (LibHaru_LIBRARY_DEBUG)
+      set_property(TARGET LibHaru::LibHaru APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(LibHaru::LibHaru PROPERTIES
+        IMPORTED_LOCATION_DEBUG "${LibHaru_LIBRARY_DEBUG}"
+        IMPORTED_IMPLIB_DEBUG "${LibHaru_LIBRARY_DEBUG}")
+    endif ()
+  endif ()
+endif ()

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

@@ -0,0 +1,67 @@
+find_path(LibPROJ_INCLUDE_DIR
+  NAMES proj_api.h proj.h
+  DOC "libproj include directories")
+mark_as_advanced(LibPROJ_INCLUDE_DIR)
+
+find_library(LibPROJ_LIBRARY_RELEASE
+  NAMES proj
+  DOC "libproj release library")
+mark_as_advanced(LibPROJ_LIBRARY_RELEASE)
+
+find_library(LibPROJ_LIBRARY_DEBUG
+  NAMES projd
+  DOC "libproj debug library")
+mark_as_advanced(LibPROJ_LIBRARY_DEBUG)
+
+include(SelectLibraryConfigurations)
+select_library_configurations(LibPROJ)
+
+if (LibPROJ_INCLUDE_DIR)
+  if (EXISTS "${LibPROJ_INCLUDE_DIR}/proj.h")
+    file(STRINGS "${LibPROJ_INCLUDE_DIR}/proj.h" _libproj_version_lines REGEX "#define[ \t]+PROJ_VERSION_(MAJOR|MINOR|PATCH)")
+    string(REGEX REPLACE ".*PROJ_VERSION_MAJOR *\([0-9]*\).*" "\\1" _libproj_version_major "${_libproj_version_lines}")
+    string(REGEX REPLACE ".*PROJ_VERSION_MINOR *\([0-9]*\).*" "\\1" _libproj_version_minor "${_libproj_version_lines}")
+    string(REGEX REPLACE ".*PROJ_VERSION_PATCH *\([0-9]*\).*" "\\1" _libproj_version_patch "${_libproj_version_lines}")
+  else ()
+    file(STRINGS "${LibPROJ_INCLUDE_DIR}/proj_api.h" _libproj_version_lines REGEX "#define[ \t]+PJ_VERSION")
+    string(REGEX REPLACE ".*PJ_VERSION *\([0-9]*\).*" "\\1" _libproj_version "${_libproj_version_lines}")
+    math(EXPR _libproj_version_major "${_libproj_version} / 100")
+    math(EXPR _libproj_version_minor "(${_libproj_version} % 100) / 10")
+    math(EXPR _libproj_version_patch "${_libproj_version} % 10")
+  endif ()
+  set(LibPROJ_VERSION "${_libproj_version_major}.${_libproj_version_minor}.${_libproj_version_patch}")
+  set(LibPROJ_MAJOR_VERSION "${_libproj_version_major}")
+  unset(_libproj_version_major)
+  unset(_libproj_version_minor)
+  unset(_libproj_version_patch)
+  unset(_libproj_version)
+  unset(_libproj_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LibPROJ
+  REQUIRED_VARS LibPROJ_LIBRARY LibPROJ_INCLUDE_DIR
+  VERSION_VAR LibPROJ_VERSION)
+
+if (LibPROJ_FOUND)
+  set(LibPROJ_INCLUDE_DIRS "${LibPROJ_INCLUDE_DIR}")
+  set(LibPROJ_LIBRARIES "${LibPROJ_LIBRARY}")
+
+  if (NOT TARGET LibPROJ::LibPROJ)
+    add_library(LibPROJ::LibPROJ UNKNOWN IMPORTED)
+    set_target_properties(LibPROJ::LibPROJ PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${LibPROJ_INCLUDE_DIR}")
+    if (LibPROJ_LIBRARY_RELEASE)
+      set_property(TARGET LibPROJ::LibPROJ APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(LibPROJ::LibPROJ PROPERTIES
+        IMPORTED_LOCATION_RELEASE "${LibPROJ_LIBRARY_RELEASE}")
+    endif ()
+    if (LibPROJ_LIBRARY_DEBUG)
+      set_property(TARGET LibPROJ::LibPROJ APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(LibPROJ::LibPROJ PROPERTIES
+        IMPORTED_LOCATION_DEBUG "${LibPROJ_LIBRARY_DEBUG}")
+    endif ()
+  endif ()
+endif ()