├── .github
    ├── scripts
    │   ├── cibw_before_build.sh
    │   ├── install.sh
    │   ├── linux_repair_wheel.py
    │   └── utils.py
    └── workflows
    │   └── build_wheels.yml
├── CMakeLists.txt
├── Examples
    └── Python
    │   ├── change_devices.py
    │   ├── cinematic_rendering
    │       ├── head_and_neck_animation.py
    │       ├── head_and_neck_front.py
    │       ├── head_and_neck_side.py
    │       └── thorax_kidneys.py
    │   ├── quilt_image.py
    │   ├── quilt_movie.py
    │   └── vtkLookingGlassPythonDemo.ipynb
├── FetchFromUrl.cmake
├── FetchHoloPlayCore.cmake
├── FetchVTKExternalModule.cmake
├── FindHoloPlayCore.cmake
├── LICENSE
├── README.md
├── Testing
    ├── CMakeLists.txt
    ├── Cxx
    │   ├── CMakeLists.txt
    │   ├── TestDragon.cxx
    │   └── TestLookingGlassPass.cxx
    └── Python
    │   ├── requirements.txt
    │   └── test_import.py
├── lib
    └── vtkmodules
    │   └── dummy.txt
├── pyproject.toml
├── setup.py
├── vtk.module
├── vtkCocoaLookingGlassRenderWindow.h
├── vtkCocoaLookingGlassRenderWindow.mm
├── vtkLookingGlassInterface.cxx
├── vtkLookingGlassInterface.h
├── vtkLookingGlassPass.cxx
├── vtkLookingGlassPass.h
├── vtkLookingGlassRenderWindowImpl.h
├── vtkWin32LookingGlassRenderWindow.cxx
├── vtkWin32LookingGlassRenderWindow.h
├── vtkXLookingGlassRenderWindow.cxx
└── vtkXLookingGlassRenderWindow.h


/.github/scripts/cibw_before_build.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -ev
 3 | 
 4 | if [[ $RUNNER_OS == "Linux" ]]; then
 5 |     # Some of the VTK modules use this library, and auditwheel will
 6 |     # complain if it can't find it. We will remove it from the wheel
 7 |     # after the repair is complete.
 8 |     yum install libXcursor-devel -y
 9 | 
10 |     # Make sure this is removed before every build, so we always
11 |     # get the correct one.
12 |     rm -rf $VTK_WHEEL_SDK_INSTALL_PATH
13 | fi
14 | 


--------------------------------------------------------------------------------
/.github/scripts/install.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -ev
 3 | 
 4 | #### Install cibuildwheel ####
 5 | pip install cibuildwheel
 6 | 
 7 | if [[ $RUNNER_OS == "macOS" ]]; then
 8 |     # VTK is expecting the xcode path to be slightly different.
 9 |     # Specifically, the VTK::RenderingOpenGL2 imported target seems
10 |     # to expect the absolute path to the OpenGL library to match.
11 |     ln -s /Applications/Xcode_13.1.app/ /Applications/Xcode-13.1.app
12 | fi
13 | 


--------------------------------------------------------------------------------
/.github/scripts/linux_repair_wheel.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import glob
 4 | import os
 5 | from pathlib import Path
 6 | import shutil
 7 | import subprocess
 8 | import sys
 9 | 
10 | from utils import change_dir, unzip_file
11 | 
12 | """
13 | This script does the following:
14 | 
15 | 1. Copy all vtk modules into the wheel
16 | 2. Run auditwheel repair
17 | 3. Remove anything that wasn't there before the repair
18 | 
19 | This is done so that we can get proper tags on the wheel, without the
20 | RPATHs or contents of the wheel being affected.
21 | 
22 | Note: if we make the VTK modules visible to auditwheel by modifying the
23 | LD_LIBRARY_PATH, auditwheel copies them into the project, but modifies
24 | the RPATHs of our libraries. We do not want auditwheel to modify the
25 | RPATHs, so we copy the VTK modules in ourselves.
26 | 
27 | It would be great if auditwheel, at some point, allowed us to add tags
28 | to the wheel *without* repairing it...
29 | """
30 | 
31 | if len(sys.argv) < 3:
32 |     sys.exit('Usage: <script> <wheel_path> <output_dir>')
33 | 
34 | wheel_path = sys.argv[1]
35 | output_dir = sys.argv[2]
36 | 
37 | wheel_sdk_path = os.getenv('VTK_WHEEL_SDK_INSTALL_PATH')
38 | if wheel_sdk_path is None:
39 |     raise Exception('VTK_WHEEL_SDK_INSTALL_PATH must be set')
40 | 
41 | vtkmodules_glob_pattern = Path(wheel_sdk_path) / 'build/*/vtkmodules/*.so'
42 | vtkmodules = glob.glob(str(vtkmodules_glob_pattern))
43 | if not vtkmodules:
44 |     raise Exception(f'Failed to find vtkmodules at: {vtkmodules_glob_pattern}')
45 | 
46 | with unzip_file(wheel_path) as unpacked_path:
47 |     # Take a snapshot of the directory contents. After the wheel repair, we
48 |     # will remove all files except for these.
49 |     with change_dir(unpacked_path):
50 |         contents_snapshot = list(Path().rglob('*'))
51 | 
52 |         # Find the path to the RECORD file
53 |         record_glob = list(Path().glob('*.dist-info/RECORD'))
54 |         if len(record_glob) != 1:
55 |             raise Exception('Failed to find RECORD file')
56 | 
57 |         record_path = record_glob[0]
58 | 
59 |         # Read in the RECORD file. We will write it back out after the repair.
60 |         with open(record_path, 'r') as rf:
61 |             record_text = rf.read()
62 | 
63 |     # Copy the vtkmodules in
64 |     destination = Path(unpacked_path) / 'vtkmodules'
65 |     for f in vtkmodules:
66 |         output = destination / Path(f).name
67 |         if output.exists():
68 |             # Don't overwrite any files
69 |             continue
70 | 
71 |         shutil.copyfile(f, output)
72 | 
73 | # Now, perform the auditwheel repair
74 | cmd = ['auditwheel', 'repair', wheel_path, '-w', output_dir]
75 | subprocess.check_call(cmd)
76 | 
77 | # There should now be a wheel in the wheelhouse
78 | output = glob.glob(f'{output_dir}/*.whl')
79 | if len(output) != 1:
80 |     raise Exception(f'Failed to find wheel in `{output_dir}`')
81 | 
82 | output_wheel = output[0]
83 | 
84 | # Now, remove all newly added files
85 | with unzip_file(output_wheel) as unpacked_path:
86 |     with change_dir(unpacked_path):
87 |         for item in Path().rglob('*'):
88 |             if item not in contents_snapshot:
89 |                 if item.is_dir():
90 |                     shutil.rmtree(item)
91 |                 else:
92 |                     item.unlink()
93 | 
94 |         # Replace the RECORD file with the old one
95 |         with open(record_path, 'w') as wf:
96 |             wf.write(record_text)
97 | 


--------------------------------------------------------------------------------
/.github/scripts/utils.py:
--------------------------------------------------------------------------------
 1 | from contextlib import contextmanager
 2 | import os
 3 | from pathlib import Path
 4 | import shutil
 5 | import zipfile
 6 | 
 7 | 
 8 | @contextmanager
 9 | def unzip_file(zip_path, unpack_path=None):
10 |     # This will unzip the file while inside the context, and re-zip it
11 |     # afterwards, which allows the caller to modify the contents
12 | 
13 |     if unpack_path is None:
14 |         unpack_path = str(Path('__tmp_unzip_file_unpack').resolve())
15 | 
16 |     with zipfile.ZipFile(zip_path, 'r') as zip_ref:
17 |         zip_ref.extractall(unpack_path)
18 | 
19 |     try:
20 |         yield unpack_path
21 |     finally:
22 |         name = shutil.make_archive(zip_path, 'zip', unpack_path)
23 |         shutil.rmtree(unpack_path)
24 |         if name.endswith('.zip'):
25 |             Path(name).rename(name[:-4])
26 | 
27 | 
28 | @contextmanager
29 | def change_dir(path):
30 |     # Temporarily change the directory to the path. When the context ends,
31 |     # the path will be changed back.
32 | 
33 |     origin = Path.cwd()
34 |     try:
35 |         os.chdir(path)
36 |         yield
37 |     finally:
38 |         os.chdir(origin)
39 | 


--------------------------------------------------------------------------------
/.github/workflows/build_wheels.yml:
--------------------------------------------------------------------------------
  1 | name: Build Wheels
  2 | 
  3 | on:
  4 |   push:
  5 |     branches:
  6 |       - master
  7 |     tags:
  8 |        - '*'
  9 |   pull_request:
 10 |     branches:
 11 |       - master
 12 | 
 13 |   workflow_dispatch:
 14 | 
 15 | env:
 16 | 
 17 |   # Supply options to `pip` to affect how it downloads vtk nightly
 18 |   # wheels from VTK gitlab package registry.
 19 |   PIP_EXTRA_INDEX_URL: https://wheels.vtk.org
 20 | 
 21 |   # Only support 64-bit CPython >= 3.8 && <= 3.12
 22 |   # VTK does not currently build python 3.8 arm64 wheels, so skip it too
 23 |   CIBW_SKIP: "cp27-* cp35-* cp36-* cp37-* cp311-* cp312-* cp313-* pp* *-manylinux_i686 *-musllinux_* *-win32 cp38-macosx_arm64"
 24 | 
 25 |   # Need to match the version used by VTK
 26 |   CIBW_ENVIRONMENT_MACOS: MACOSX_DEPLOYMENT_TARGET=10.10
 27 | 
 28 |   # In the Linux docker container, install the wheel SDKs to this location
 29 |   CIBW_ENVIRONMENT_LINUX: VTK_WHEEL_SDK_INSTALL_PATH=/vtk-wheel-sdk
 30 | 
 31 |   # VTK already fixes the rpaths, so we can skip this step for MacOS
 32 |   CIBW_REPAIR_WHEEL_COMMAND_MACOS:
 33 | 
 34 |   # On Linux, we only need auditwheel to add the tags to the wheel.
 35 |   # Unfortunately, auditwheel currently requires us to repair the wheel to
 36 |   # add the tags, even though we do not need to repair the wheel.
 37 |   # Thus, we need to set everything up for a wheel repair (including placing
 38 |   # the VTK libraries in `vtkmodules`, where they are expected to be at
 39 |   # runtime), perform the wheel repair, and then remove the added libraries.
 40 |   # Then the tags will have been added.
 41 |   CIBW_REPAIR_WHEEL_COMMAND_LINUX: .github/scripts/linux_repair_wheel.py {wheel} {dest_dir}
 42 | 
 43 |   # Pass these variables into the Linux docker containers
 44 |   CIBW_ENVIRONMENT_PASS_LINUX: RUNNER_OS VTK_WHEEL_SDK_INSTALL_PATH PIP_EXTRA_INDEX_URL
 45 | 
 46 |   # Run this before every build
 47 |   CIBW_BEFORE_BUILD: bash .github/scripts/cibw_before_build.sh
 48 | 
 49 |   CIBW_TEST_COMMAND: >
 50 |     pip install -r {package}/Testing/Python/requirements.txt &&
 51 |     pytest {package}/Testing/Python
 52 | 
 53 | # Use bash by default for the run command
 54 | defaults:
 55 |   run:
 56 |     shell: bash
 57 | 
 58 | jobs:
 59 |   build_wheels:
 60 |     name: Build wheels on ${{ matrix.os }}
 61 |     runs-on: ${{ matrix.os }}
 62 |     strategy:
 63 |       fail-fast: false
 64 |       matrix:
 65 |         os: [ubuntu-latest, macos-latest, windows-latest]
 66 | 
 67 |     steps:
 68 |       - uses: actions/checkout@v2
 69 | 
 70 |       - uses: actions/setup-python@v2
 71 |         name: Install Python
 72 |         with:
 73 |           python-version: '3.9'
 74 | 
 75 |       - name: Install dependencies
 76 |         run: bash .github/scripts/install.sh
 77 | 
 78 |       - name: Build wheels
 79 |         run: cibuildwheel --output-dir wheelhouse
 80 | 
 81 |       - name: Upload skbuild if an error occurred (for debugging)
 82 |         if: ${{ failure() }}
 83 |         uses: actions/upload-artifact@v4
 84 |         with:
 85 |           name: skbuild
 86 |           path: ${{ github.workspace }}/_skbuild
 87 | 
 88 |       - uses: actions/upload-artifact@v4
 89 |         with:
 90 |           name: "artifacts-${{ matrix.os }}"
 91 |           path: ./wheelhouse/*.whl
 92 | 
 93 |   upload_pypi:
 94 |     needs: build_wheels
 95 |     name: Upload wheels to PyPI
 96 |     runs-on: ubuntu-latest
 97 |     # upload to PyPI on every tag push
 98 |     if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/')
 99 |     steps:
100 |       - uses: actions/download-artifact@v2
101 |         with:
102 |           name: artifact
103 |           path: dist
104 | 
105 |       - uses: pypa/gh-action-pypi-publish@master
106 |         with:
107 |           user: __token__
108 |           password: ${{ secrets.PYPI_API_TOKEN }}
109 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | message(STATUS "LookingGlass: Building as a Remote VTK module")
 2 | 
 3 | list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR})
 4 | 
 5 | set(classes
 6 |   vtkLookingGlassInterface
 7 |   vtkLookingGlassPass
 8 | )
 9 | 
10 | # add OS specic render window implementation
11 | if (VTK_USE_X)
12 |   list(APPEND classes vtkXLookingGlassRenderWindow)
13 | elseif (WIN32)
14 |   list(APPEND classes vtkWin32LookingGlassRenderWindow)
15 | elseif (VTK_USE_COCOA)
16 |   list(APPEND sources vtkCocoaLookingGlassRenderWindow.mm)
17 |   list(APPEND headers vtkCocoaLookingGlassRenderWindow.h)
18 | endif()
19 | 
20 | 
21 | vtk_module_add_module(VTK::RenderingLookingGlass
22 |   CLASSES ${classes}
23 |   SOURCES ${sources}
24 |   HEADERS ${headers}
25 | )
26 | 
27 | if (NOT HoloPlayCore_INCLUDE_DIR OR NOT HoloPlayCore_LIBRARY)
28 |   # Download HoloPlayCore if it is not set already
29 |   include(FetchHoloPlayCore)
30 | endif()
31 | 
32 | vtk_module_find_package(PACKAGE HoloPlayCore)
33 | vtk_module_link(VTK::RenderingLookingGlass
34 |     PUBLIC HoloPlayCore::HoloPlayCore)
35 | if (APPLE)
36 |   vtk_module_link(VTK::RenderingLookingGlass
37 |     PRIVATE "-framework IOKit")
38 | endif ()
39 | 
40 | # Copy the FindHoloPlayCore.cmake file to the build directory
41 | if (DEFINED vtk_cmake_build_dir)
42 |   configure_file(
43 |     "${CMAKE_CURRENT_SOURCE_DIR}/FindHoloPlayCore.cmake"
44 |     "${vtk_cmake_build_dir}/FindHoloPlayCore.cmake"
45 |     COPYONLY)
46 | endif ()
47 | 
48 | # Workaround limitation of VTK build-system preventing export module specific CMake variables
49 | # in module config files.
50 | if (DEFINED vtk_cmake_destination AND VTK_BINARY_DIR)
51 |   configure_file(
52 |     "${CMAKE_CURRENT_SOURCE_DIR}/FindHoloPlayCore.cmake"
53 |     "${VTK_BINARY_DIR}/${vtk_cmake_destination}/FindHoloPlayCore.cmake"
54 |     COPYONLY)
55 | endif ()
56 | 
57 | if (DEFINED vtk_cmake_destination)
58 |   install(
59 |     FILES "${CMAKE_CURRENT_SOURCE_DIR}/FindHoloPlayCore.cmake"
60 |     DESTINATION "${vtk_cmake_destination}"
61 |     COMPONENT   "development")
62 | endif ()
63 | 
64 | if (VTK_WHEEL_BUILD)
65 |   # Need to install the HoloPlayCore_RUNTIME_LIBRARY
66 |   # FIXME: can we find a way to NOT set the DESTINATION manually?
67 |   install(
68 |     FILES "${HoloPlayCore_RUNTIME_LIBRARY}"
69 |     DESTINATION "${CMAKE_INSTALL_LIBDIR}/vtkmodules")
70 | endif()
71 | 


--------------------------------------------------------------------------------
/Examples/Python/change_devices.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | """This example demonstrates changing device types
 4 | 
 5 | The code loops through each device type and writes out a quilt image for
 6 | each one.
 7 | """
 8 | 
 9 | import vtk
10 | from vtk import vtkRenderingLookingGlass
11 | 
12 | # Create a looking glass render window
13 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
14 | 
15 | # Declare a VTK rendering process, and add it to the window
16 | ren = vtk.vtkRenderer()
17 | renWin.AddRenderer(ren)
18 | 
19 | # Add a cone
20 | cone = vtk.vtkConeSource()
21 | cone.SetRadius(2)
22 | cone.SetHeight(4)
23 | cone.SetCenter(4, 4, 2)
24 | cone.SetDirection(0, 0, 0)
25 | coneMapper = vtk.vtkPolyDataMapper()
26 | coneMapper.SetInputConnection(cone.GetOutputPort())
27 | coneActor = vtk.vtkActor()
28 | coneActor.SetMapper(coneMapper)
29 | ren.AddActor(coneActor)
30 | 
31 | # Initialize the window
32 | renWin.Initialize()
33 | ren.ResetCamera()
34 | ren.GetActiveCamera().SetViewAngle(30)
35 | 
36 | # Loop through each device type
37 | for device_type in renWin.GetDeviceTypes():
38 |     # Switch to the device
39 |     renWin.SetDeviceType(device_type)
40 | 
41 |     # Must render before writing out the quilt
42 |     renWin.Render()
43 | 
44 |     # The suffix encodes the tile pattern, such as "_qs5x9"
45 |     # This allows software to automatically determine the tile pattern
46 |     suffix = renWin.QuiltFileSuffix()
47 | 
48 |     # Write out the quilt
49 |     renWin.SaveQuilt(f"quilt_{device_type}{suffix}.png")
50 | 


--------------------------------------------------------------------------------
/Examples/Python/cinematic_rendering/head_and_neck_animation.py:
--------------------------------------------------------------------------------
  1 | """Generate a camera animation of the head and neck example
  2 | 
  3 | Running this script generates a video quilt file that can be
  4 | played on a Looking Glass device via HoloPlay Studio. While the
  5 | script is running, the latest frame generated can be seen on the
  6 | device. However, due to computing constraints, the time between the
  7 | frames may be significantly longer than that of the video file that
  8 | is produced.
  9 | 
 10 | Note that HoloPlay Studio requires the video file to be in MP4
 11 | or WEBM format. If VTK writes out the video in a different format,
 12 | it may need to be converted. Here's an example of a conversion
 13 | using ffmpeg:
 14 | 
 15 | ffmpeg -i input_file.ogv -c:v libx265 -pix_fmt yuv420p -crf 10 output_file.mp4
 16 | 
 17 | Where `libx265` specifies to use the h.265 video codec, `crf`
 18 | specifies the video quality (where 0 is lossless and 51 is the lowest
 19 | quality), and 'pix_fmt' is required if you want to include the
 20 | mp4 in a playlist that is sync'd with a portrait device.
 21 | 
 22 | Example output of this script that was generated for a 16" device and
 23 | converted to MP4 may be found here:
 24 | 
 25 | https://drive.google.com/file/d/1WUFDhrcLsajCV7TUoNKFCII1VGNHcrz_/view?usp=sharing
 26 | """
 27 | 
 28 | from pathlib import Path
 29 | import signal
 30 | 
 31 | import numpy as np
 32 | 
 33 | import vtk
 34 | 
 35 | from vtk import vtkRenderingLookingGlass
 36 | 
 37 | # Kill the program when ctrl-c is used
 38 | signal.signal(signal.SIGINT, signal.SIG_DFL)
 39 | 
 40 | data_url = "https://data.kitware.com/api/v1/file/62daaa69bddec9d0c4bfd42a/download"
 41 | data_file = "head_and_neck_ct.vtk"
 42 | 
 43 | if not Path(data_file).exists():
 44 |     print(f"Downloading {data_file}...")
 45 | 
 46 |     # Download the data
 47 |     import urllib.request
 48 |     urllib.request.urlretrieve(data_url, data_file)
 49 | 
 50 |     print("Download complete")
 51 | 
 52 | 
 53 | # Volumetric shadow settings
 54 | volumetric_scattering_blending = 2
 55 | global_illumination_reach = 0.2
 56 | 
 57 | # Read the data
 58 | reader = vtk.vtkStructuredPointsReader()
 59 | reader.SetFileName(data_file)
 60 | reader.Update()
 61 | image = reader.GetOutput()
 62 | 
 63 | ren = vtk.vtkRenderer()
 64 | ren.SetBackground(0, 0, 0)
 65 | 
 66 | # renWin = vtk.vtkRenderWindow()
 67 | # renWin.SetSize(800, 800)
 68 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
 69 | 
 70 | renWin.SetDeviceType("portrait")
 71 | 
 72 | renWin.AddRenderer(ren)
 73 | 
 74 | volume_prop = vtk.vtkVolumeProperty()
 75 | volume_prop.ShadeOn()
 76 | volume_prop.SetScalarOpacityUnitDistance(1.5)
 77 | volume_prop.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
 78 | 
 79 | # volume_prop.SetDiffuse(1.0)
 80 | # volume_prop.SetAmbient(0.3)
 81 | # volume_prop.SetSpecular(0.1)
 82 | # volume_prop.SetSpecularPower(2.0)
 83 | 
 84 | color = vtk.vtkColorTransferFunction()
 85 | color.SetColorSpaceToDiverging()
 86 | color.AllowDuplicateScalarsOn()
 87 | color.SetRange(-2864.0, 3231.0)
 88 | color.AddRGBPoint(66.0, 0.529412, 0.156863, 0.145098)
 89 | color.AddRGBPoint(124.133, 0.541176, 0.168627, 0.168627)
 90 | color.AddRGBPoint(144.24, 0.882353, 0.603922, 0.290196)
 91 | color.AddRGBPoint(167.027, 0.74902, 0.662745, 0.662745)
 92 | color.AddRGBPoint(189.814, 0.839216, 0.643137, 0.47451)
 93 | color.AddRGBPoint(217.963, 1.0, 0.937033, 0.954531)
 94 | color.AddRGBPoint(409.412, 0.521569, 0.529412, 0.6)
 95 | color.AddRGBPoint(3231.0, 0.827451, 0.658824, 1.0)
 96 | volume_prop.SetColor(color)
 97 | 
 98 | opacity = vtk.vtkPiecewiseFunction()
 99 | opacity.AllowDuplicateScalarsOn()
100 | opacity.AddPoint(-2864.0, 0.0)
101 | opacity.AddPoint(-136.837, 0.0)
102 | opacity.AddPoint(75.8777, 0.0)
103 | opacity.AddPoint(81.2394, 0.180531)
104 | opacity.AddPoint(89.282, 0.339324)
105 | opacity.AddPoint(102.686, 0.439615)
106 | opacity.AddPoint(155.059, 0.536765)
107 | opacity.AddPoint(249.496, 0.661765)
108 | opacity.AddPoint(489.881, 0.860294)
109 | opacity.AddPoint(3231.0, 0.875)
110 | volume_prop.SetScalarOpacity(opacity)
111 | 
112 | volume = vtk.vtkVolume()
113 | volume.SetProperty(volume_prop)
114 | 
115 | mapper = vtk.vtkGPUVolumeRayCastMapper()
116 | mapper.SetInputData(image)
117 | mapper.SetBlendModeToComposite()
118 | mapper.UseJitteringOn()
119 | mapper.SetVolumetricScatteringBlending(volumetric_scattering_blending)
120 | mapper.SetGlobalIlluminationReach(global_illumination_reach)
121 | volume.SetMapper(mapper)
122 | 
123 | # Set up the lights
124 | ren.ClearLights()
125 | ren.RemoveAllLights()
126 | 
127 | light1 = vtk.vtkLight()
128 | light1.SetPosition(1168.3321375771598, 1103.6856851906775, 1332.4963456361356)
129 | light1.SetFocalPoint(-0.8162294972326031, 98.8382341239513, 679.6689345111414)
130 | 
131 | light2 = vtk.vtkLight()
132 | light2.SetPositional(True)
133 | light2.SetPosition(-1775.4343728259555, 1468.4250542292532, 2617.078008761073)
134 | light2.SetFocalPoint(1.3923130086732531, 96.00624836304287, 679.096642063474)
135 | light2.SetConeAngle(41.4)
136 | 
137 | light3 = vtk.vtkLight()
138 | light3.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT)
139 | light3.SetIntensity(0.1)
140 | 
141 | light4 = vtk.vtkLight()
142 | light4.SetPosition(10.192943271554737, 1032.6546874457033, 534.6410709339551)
143 | light4.SetFocalPoint(-0.8925092249604016, 98.88633737379182, 679.6079704046107)
144 | 
145 | for light in (light1, light2, light3, light4):
146 |     ren.AddLight(light)
147 | 
148 | # Adjust the camera
149 | camera = ren.GetActiveCamera()
150 | camera.SetPosition(39.28837393041376, 753.6814804302966, 614.2672454604013)
151 | camera.SetFocalPoint(6.708621478744433, 164.7269185790301, 675.9562549433067)
152 | camera.SetViewUp(0, 0, 1)
153 | 
154 | 
155 | def rotate_camera_xy(angle):
156 |     angle = np.radians(angle)
157 | 
158 |     pos = np.array(camera.GetPosition())
159 |     fp = np.array(camera.GetFocalPoint())
160 | 
161 |     # Translate so that the focal point is centered
162 |     pos -= fp
163 | 
164 |     # Perform the rotation
165 |     s = np.sin(angle)
166 |     c = np.cos(angle)
167 | 
168 |     x = pos[0] * c - pos[1] * s
169 |     y = pos[0] * s + pos[1] * c
170 | 
171 |     pos[0] = x
172 |     pos[1] = y
173 | 
174 |     # Translate back
175 |     pos += fp
176 | 
177 |     camera.SetPosition(pos)
178 | 
179 | 
180 | ren.AddActor(volume)
181 | 
182 | suffix = renWin.QuiltFileSuffix()
183 | ext = renWin.MovieFileExtension()
184 | renWin.StartRecordingQuilt(f"head_and_neck{suffix}.{ext}")
185 | 
186 | angle_range = (-60, 60)
187 | num_frames = 100
188 | 
189 | step_size = (angle_range[1] - angle_range[0]) / (num_frames - 1)
190 | 
191 | # First, rotate to the first angle
192 | rotate_camera_xy(angle_range[0])
193 | renWin.Render()
194 | 
195 | # Now step through the rest of the angles
196 | for _ in range(num_frames):
197 |     rotate_camera_xy(step_size)
198 |     renWin.Render()
199 | 
200 | # Now, go backwards
201 | for _ in range(num_frames):
202 |     rotate_camera_xy(-step_size)
203 |     renWin.Render()
204 | 
205 | renWin.StopRecordingQuilt()
206 | 


--------------------------------------------------------------------------------
/Examples/Python/cinematic_rendering/head_and_neck_front.py:
--------------------------------------------------------------------------------
  1 | from pathlib import Path
  2 | import signal
  3 | 
  4 | import numpy as np
  5 | import logging
  6 | 
  7 | import vtk
  8 | 
  9 | from vtk import vtkRenderingLookingGlass
 10 | 
 11 | # Kill the program when ctrl-c is used
 12 | signal.signal(signal.SIGINT, signal.SIG_DFL)
 13 | 
 14 | logging.basicConfig(level=logging.INFO)
 15 | 
 16 | data_url = "https://data.kitware.com/api/v1/file/62daaa69bddec9d0c4bfd42a/download"
 17 | data_file = "head_and_neck_ct.vtk"
 18 | 
 19 | if not Path(data_file).exists():
 20 |     print(f"Downloading {data_file}...")
 21 | 
 22 |     # Download the data
 23 |     import urllib.request
 24 |     urllib.request.urlretrieve(data_url, data_file)
 25 | 
 26 |     print("Download complete")
 27 | 
 28 | # Volumetric shadow settings
 29 | volumetric_scattering_blending = 2
 30 | global_illumination_reach = 0.2
 31 | 
 32 | # Read the data
 33 | reader = vtk.vtkStructuredPointsReader()
 34 | reader.SetFileName(data_file)
 35 | reader.Update()
 36 | image = reader.GetOutput()
 37 | 
 38 | ren = vtk.vtkRenderer()
 39 | ren.SetBackground(0, 0, 0)
 40 | 
 41 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
 42 | 
 43 | 
 44 | renWin.AddRenderer(ren)
 45 | 
 46 | iren = vtk.vtkRenderWindowInteractor()
 47 | iren.SetRenderWindow(renWin)
 48 | 
 49 | # The desired update rate is for a single render of the renderer.
 50 | # For the looking glass, however, there will be one render for each
 51 | # tile. Thus, we should modify the desired update rate to be the
 52 | # previous update rate * the number of tiles, in order to improve
 53 | # render rate during interaction.
 54 | num_tiles = np.prod(renWin.GetInterface().GetQuiltTiles())
 55 | iren.SetDesiredUpdateRate(iren.GetDesiredUpdateRate() * num_tiles)
 56 | 
 57 | volume_prop = vtk.vtkVolumeProperty()
 58 | volume_prop.ShadeOn()
 59 | volume_prop.SetScalarOpacityUnitDistance(1.5)
 60 | volume_prop.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
 61 | 
 62 | volume_prop_l = vtk.vtkVolumeProperty()
 63 | volume_prop_l.ShadeOn()
 64 | volume_prop_l.SetScalarOpacityUnitDistance(1.5)
 65 | volume_prop_l.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
 66 | 
 67 | # volume_prop.SetDiffuse(1.0)
 68 | # volume_prop.SetAmbient(0.3)
 69 | # volume_prop.SetSpecular(0.1)
 70 | # volume_prop.SetSpecularPower(2.0)
 71 | 
 72 | color = vtk.vtkColorTransferFunction()
 73 | color.SetColorSpaceToDiverging()
 74 | color.AllowDuplicateScalarsOn()
 75 | color.SetRange(-2864.0, 3231.0)
 76 | color.AddRGBPoint(66.0, 0.529412, 0.156863, 0.145098)
 77 | color.AddRGBPoint(124.133, 0.541176, 0.168627, 0.168627)
 78 | color.AddRGBPoint(144.24, 0.882353, 0.603922, 0.290196)
 79 | color.AddRGBPoint(167.027, 0.74902, 0.662745, 0.662745)
 80 | color.AddRGBPoint(189.814, 0.839216, 0.643137, 0.47451)
 81 | color.AddRGBPoint(217.963, 1.0, 0.937033, 0.954531)
 82 | color.AddRGBPoint(409.412, 0.521569, 0.529412, 0.6)
 83 | color.AddRGBPoint(3231.0, 0.827451, 0.658824, 1.0)
 84 | volume_prop.SetColor(color)
 85 | 
 86 | opacity = vtk.vtkPiecewiseFunction()
 87 | opacity.AllowDuplicateScalarsOn()
 88 | opacity.AddPoint(-2864.0, 0.0)
 89 | opacity.AddPoint(-136.837, 0.0)
 90 | opacity.AddPoint(75.8777, 0.0)
 91 | opacity.AddPoint(81.2394, 0.180531)
 92 | opacity.AddPoint(89.282, 0.339324)
 93 | opacity.AddPoint(102.686, 0.439615)
 94 | opacity.AddPoint(155.059, 0.536765)
 95 | opacity.AddPoint(249.496, 0.661765)
 96 | opacity.AddPoint(489.881, 0.860294)
 97 | opacity.AddPoint(3231.0, 0.875)
 98 | volume_prop.SetScalarOpacity(opacity)
 99 | 
100 | opacity_l = vtk.vtkPiecewiseFunction()
101 | opacity_l.AddPoint(-1000, 0)
102 | opacity_l.AddPoint(-600, 0)
103 | opacity_l.AddPoint(-599, 0.15)
104 | opacity_l.AddPoint(-400, 0.15)
105 | opacity_l.AddPoint(-399, 0)
106 | opacity_l.AddPoint(2952, 0)
107 | volume_prop_l.SetScalarOpacity(opacity_l)
108 | 
109 | color_l = vtk.vtkColorTransferFunction()
110 | color_l.AddRGBPoint(-1000, 0.3, 0.3, 1)
111 | color_l.AddRGBPoint(-600, 0, 0, 1)
112 | color_l.AddRGBPoint(-530, 0.134704, 0.781726, 0.0724558)
113 | color_l.AddRGBPoint(-460, 0.929244, 1, 0.109473)
114 | color_l.AddRGBPoint(-400, 0.888889, 0.254949, 0.0240258)
115 | color_l.AddRGBPoint(2952, 1, 0.3, 0.3)
116 | volume_prop_l.SetColor(color_l)
117 | 
118 | volume = vtk.vtkVolume()
119 | volume.SetProperty(volume_prop)
120 | 
121 | def on_key_press(style, event):
122 |     if style.GetInteractor().GetKeySym() == 'l':
123 |         logging.info('Switching to lung TF')
124 |         volume.SetProperty(volume_prop_l)
125 |         renWin.Render()
126 |     elif style.GetInteractor().GetKeySym() == 'b':
127 |         logging.info('Switching to bone TF')
128 |         volume.SetProperty(volume_prop)
129 |         renWin.Render()
130 | 
131 | mapper = vtk.vtkGPUVolumeRayCastMapper()
132 | mapper.SetInputData(image)
133 | mapper.SetBlendModeToComposite()
134 | mapper.UseJitteringOn()
135 | mapper.SetVolumetricScatteringBlending(volumetric_scattering_blending)
136 | mapper.SetGlobalIlluminationReach(global_illumination_reach)
137 | volume.SetMapper(mapper)
138 | 
139 | # Set up the lights
140 | ren.ClearLights()
141 | ren.RemoveAllLights()
142 | 
143 | light1 = vtk.vtkLight()
144 | light1.SetPosition(1168.3321375771598, 1103.6856851906775, 1332.4963456361356)
145 | light1.SetFocalPoint(-0.8162294972326031, 98.8382341239513, 679.6689345111414)
146 | 
147 | light2 = vtk.vtkLight()
148 | light2.SetPositional(True)
149 | light2.SetPosition(-1775.4343728259555, 1468.4250542292532, 2617.078008761073)
150 | light2.SetFocalPoint(1.3923130086732531, 96.00624836304287, 679.096642063474)
151 | light2.SetConeAngle(41.4)
152 | 
153 | light3 = vtk.vtkLight()
154 | light3.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT)
155 | light3.SetIntensity(0.1)
156 | 
157 | light4 = vtk.vtkLight()
158 | light4.SetPosition(10.192943271554737, 1032.6546874457033, 534.6410709339551)
159 | light4.SetFocalPoint(-0.8925092249604016, 98.88633737379182, 679.6079704046107)
160 | 
161 | for light in (light1, light2, light3, light4):
162 |     ren.AddLight(light)
163 | 
164 | # Adjust the camera
165 | camera = ren.GetActiveCamera()
166 | camera.SetPosition(39.28837393041376, 753.6814804302966, 614.2672454604013)
167 | camera.SetFocalPoint(6.708621478744433, 164.7269185790301, 675.9562549433067)
168 | camera.SetViewUp(0.01802597816737277, 0.10317003294046821, 0.9945003813041864)
169 | 
170 | ren.AddActor(volume)
171 | 
172 | # Set up the interactor style
173 | iren_style = vtk.vtkInteractorStyleTrackballCamera()
174 | iren.SetInteractorStyle(iren_style)
175 | iren_style.AddObserver("KeyPressEvent", on_key_press)
176 | 
177 | def adjust_resolution(mapper, event):
178 |     interactive = volume.GetAllocatedRenderTime() < 1
179 |     mapper.SetAutoAdjustSampleDistances(not interactive)
180 |     mapper.SetVolumetricScatteringBlending(0.0 if interactive else volumetric_scattering_blending)
181 |     mapper.SetAutoAdjustSampleDistances(not interactive)
182 |     mapper.SetSampleDistance(5.0 if interactive else 1.0)
183 |     light1.SetSwitch(not interactive)
184 |     light2.SetSwitch(not interactive)
185 |     light3.SetSwitch(not interactive)
186 |     light4.SetSwitch(not interactive)
187 | 
188 | mapper.AddObserver("VolumeMapperRenderStartEvent", adjust_resolution)
189 | 
190 | print("Starting rendering. Click display window and press 'q' to exit")
191 | 
192 | iren.Start()
193 | 


--------------------------------------------------------------------------------
/Examples/Python/cinematic_rendering/head_and_neck_side.py:
--------------------------------------------------------------------------------
  1 | from pathlib import Path
  2 | import signal
  3 | 
  4 | import numpy as np
  5 | 
  6 | import vtk
  7 | 
  8 | from vtk import vtkRenderingLookingGlass
  9 | 
 10 | # Kill the program when ctrl-c is used
 11 | signal.signal(signal.SIGINT, signal.SIG_DFL)
 12 | 
 13 | data_url = "https://data.kitware.com/api/v1/file/62daaa69bddec9d0c4bfd42a/download"
 14 | data_file = "head_and_neck_ct.vtk"
 15 | 
 16 | if not Path(data_file).exists():
 17 |     print(f"Downloading {data_file}...")
 18 | 
 19 |     # Download the data
 20 |     import urllib.request
 21 |     urllib.request.urlretrieve(data_url, data_file)
 22 | 
 23 |     print("Download complete")
 24 | 
 25 | # Volumetric shadow settings
 26 | volumetric_scattering_blending = 2
 27 | global_illumination_reach = 0.2
 28 | 
 29 | # Read the data
 30 | reader = vtk.vtkStructuredPointsReader()
 31 | reader.SetFileName(data_file)
 32 | reader.Update()
 33 | image = reader.GetOutput()
 34 | 
 35 | ren = vtk.vtkRenderer()
 36 | ren.SetBackground(0, 0, 0)
 37 | 
 38 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
 39 | 
 40 | if renWin.GetDeviceType() == "standard":
 41 |     # This looks better on large settings
 42 |     renWin.SetDeviceType("large")
 43 | 
 44 | renWin.AddRenderer(ren)
 45 | 
 46 | iren = vtk.vtkRenderWindowInteractor()
 47 | iren.SetRenderWindow(renWin)
 48 | 
 49 | # The desired update rate is for a single render of the renderer.
 50 | # For the looking glass, however, there will be one render for each
 51 | # tile. Thus, we should modify the desired update rate to be the
 52 | # previous update rate * the number of tiles, in order to improve
 53 | # render rate during interaction.
 54 | num_tiles = np.prod(renWin.GetInterface().GetQuiltTiles())
 55 | iren.SetDesiredUpdateRate(iren.GetDesiredUpdateRate() * num_tiles)
 56 | 
 57 | volume_prop = vtk.vtkVolumeProperty()
 58 | volume_prop.ShadeOn()
 59 | volume_prop.SetScalarOpacityUnitDistance(1.1509873813643359)
 60 | volume_prop.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
 61 | 
 62 | # volume_prop.SetDiffuse(1.0)
 63 | # volume_prop.SetAmbient(0.3)
 64 | # volume_prop.SetSpecular(0.1)
 65 | # volume_prop.SetSpecularPower(2.0)
 66 | 
 67 | color = vtk.vtkColorTransferFunction()
 68 | color.SetColorSpaceToDiverging()
 69 | color.AllowDuplicateScalarsOn()
 70 | color.SetRange(-2864.0, 3231.0)
 71 | color.AddRGBPoint(66.0, 0.529412, 0.156863, 0.145098)
 72 | color.AddRGBPoint(124.133, 0.541176, 0.168627, 0.168627)
 73 | color.AddRGBPoint(144.24, 0.882353, 0.603922, 0.290196)
 74 | color.AddRGBPoint(167.027, 0.74902, 0.662745, 0.662745)
 75 | color.AddRGBPoint(189.814, 0.839216, 0.643137, 0.47451)
 76 | color.AddRGBPoint(217.963, 1.0, 0.937033, 0.954531)
 77 | color.AddRGBPoint(409.412, 0.521569, 0.529412, 0.6)
 78 | color.AddRGBPoint(3231.0, 0.827451, 0.658824, 1.0)
 79 | volume_prop.SetColor(color)
 80 | 
 81 | opacity = vtk.vtkPiecewiseFunction()
 82 | opacity.AllowDuplicateScalarsOn()
 83 | opacity.AddPoint(-2864.0, 0.0)
 84 | opacity.AddPoint(-136.837, 0.0)
 85 | opacity.AddPoint(75.8777, 0.0)
 86 | opacity.AddPoint(81.2394, 0.180531)
 87 | opacity.AddPoint(89.282, 0.339324)
 88 | opacity.AddPoint(102.686, 0.439615)
 89 | opacity.AddPoint(155.059, 0.536765)
 90 | opacity.AddPoint(249.496, 0.661765)
 91 | opacity.AddPoint(489.881, 0.860294)
 92 | opacity.AddPoint(3231.0, 0.875)
 93 | volume_prop.SetScalarOpacity(opacity)
 94 | 
 95 | volume = vtk.vtkVolume()
 96 | volume.SetProperty(volume_prop)
 97 | 
 98 | mapper = vtk.vtkGPUVolumeRayCastMapper()
 99 | mapper.SetInputData(image)
100 | mapper.SetBlendModeToComposite()
101 | mapper.UseJitteringOn()
102 | mapper.SetVolumetricScatteringBlending(volumetric_scattering_blending)
103 | mapper.SetGlobalIlluminationReach(global_illumination_reach)
104 | volume.SetMapper(mapper)
105 | 
106 | # Set up the lights
107 | ren.ClearLights()
108 | ren.RemoveAllLights()
109 | 
110 | light1 = vtk.vtkLight()
111 | light1.SetPosition(664.1753334478092, -764.1332325516312, 1531.7763222661922)
112 | light1.SetFocalPoint(2.3145678210753973, 107.51311161468337, 685.2954455758255)
113 | 
114 | light2 = vtk.vtkLight()
115 | light2.SetPositional(True)
116 | light2.SetPosition(1256.510929377065, 167.79381993643014, 1782.3720818721454)
117 | light2.SetFocalPoint(-6.485778011067196, 103.69246185935256, 685.3122540216165)
118 | light2.SetConeAngle(48)
119 | 
120 | light3 = vtk.vtkLight()
121 | light3.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT)
122 | 
123 | light4 = vtk.vtkLight()
124 | light4.SetPosition(4262.688089791584, 897.4946909198911, 3644.5979620782014)
125 | light4.SetFocalPoint(-5.6980060278888836, 105.2549118197128, 684.840396121795)
126 | 
127 | for light in (light1, light2, light3, light4):
128 |     ren.AddLight(light)
129 | 
130 | # Adjust the camera
131 | camera = ren.GetActiveCamera()
132 | camera.SetPosition(583.0964911648575, 428.79195498984876, 661.5251868954026)
133 | camera.SetFocalPoint(46.636364907324946, 124.35708927120413, 675.7867746525995)
134 | camera.SetViewUp(0.044156836035224814, -0.03103317479528672, 0.998542495787477)
135 | 
136 | ren.AddActor(volume)
137 | 
138 | # Set up the interactor style
139 | iren_style = vtk.vtkInteractorStyleTrackballCamera()
140 | iren.SetInteractorStyle(iren_style)
141 | 
142 | def adjust_resolution(mapper, event):
143 |     interactive = volume.GetAllocatedRenderTime() < 1
144 |     mapper.SetUseJittering(not interactive)
145 |     volume_prop.SetShade(not interactive)
146 | 
147 | mapper.AddObserver("VolumeMapperRenderStartEvent", adjust_resolution)
148 | 
149 | print("Starting rendering. Click display window and press 'q' to exit")
150 | 
151 | iren.Start()
152 | 


--------------------------------------------------------------------------------
/Examples/Python/cinematic_rendering/thorax_kidneys.py:
--------------------------------------------------------------------------------
  1 | from pathlib import Path
  2 | import signal
  3 | import sys
  4 | 
  5 | import vtk
  6 | 
  7 | from vtk import vtkRenderingLookingGlass
  8 | 
  9 | # Kill the program when ctrl-c is used
 10 | signal.signal(signal.SIGINT, signal.SIG_DFL)
 11 | 
 12 | data_url = "https://data.kitware.com/api/v1/file/62d9672ebddec9d0c4af738a/download"
 13 | data_file = "thorax_kidneys.vti"
 14 | 
 15 | if not Path(data_file).exists():
 16 |     print(f"Downloading data to {data_file}")
 17 | 
 18 |     # Download the data
 19 |     import urllib.request
 20 |     urllib.request.urlretrieve(data_url, data_file)
 21 | 
 22 |     print("Download complete")
 23 | 
 24 | # Volumetric shadow settings
 25 | volumetric_scattering_blending = 2
 26 | global_illumination_reach = 0.35964
 27 | 
 28 | # Read the data
 29 | reader = vtk.vtkXMLImageDataReader()
 30 | reader.SetFileName(data_file)
 31 | reader.Update()
 32 | image = reader.GetOutput()
 33 | 
 34 | ren = vtk.vtkRenderer()
 35 | ren.SetBackground(0, 0, 0)
 36 | 
 37 | # renWin = vtk.vtkRenderWindow()
 38 | # renWin.SetSize(800, 800)
 39 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
 40 | 
 41 | if renWin.GetDeviceType() == "standard":
 42 |     # This looks better on large settings
 43 |     renWin.SetDeviceType("large")
 44 | 
 45 | renWin.AddRenderer(ren)
 46 | 
 47 | iren = vtk.vtkRenderWindowInteractor()
 48 | iren.SetRenderWindow(renWin)
 49 | 
 50 | # Interaction is slow for this example, since it is in high res,
 51 | # so just disable it via vtkInteractorStyleUser.
 52 | iren_style = vtk.vtkInteractorStyleUser()
 53 | iren.SetInteractorStyle(iren_style)
 54 | 
 55 | # Use q to quit
 56 | def on_key_press(style, event):
 57 |     if style.GetKeySym() == 'q':
 58 |         sys.exit()
 59 | 
 60 | iren_style.AddObserver("KeyPressEvent", on_key_press)
 61 | 
 62 | volume_prop = vtk.vtkVolumeProperty()
 63 | volume_prop.ShadeOn()
 64 | volume_prop.SetScalarOpacityUnitDistance(1)
 65 | volume_prop.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
 66 | 
 67 | volume_prop.SetDiffuse(1.0)
 68 | volume_prop.SetAmbient(0.3)
 69 | volume_prop.SetSpecular(0.1)
 70 | volume_prop.SetSpecularPower(2.0)
 71 | 
 72 | color = vtk.vtkColorTransferFunction()
 73 | color.SetColorSpaceToDiverging()
 74 | color.AllowDuplicateScalarsOn()
 75 | color.SetRange(66.1394, 1648.0055)
 76 | color.AddRGBPoint(66.1394, 0.231373, 0.298039, 0.752941)
 77 | color.AddRGBPoint(153.329, 0.678431, 0.4, 0.4)
 78 | color.AddRGBPoint(223.911, 0.865003, 0.865003, 0.865003)
 79 | color.AddRGBPoint(1540.06, 0.901961, 0.847059, 0.811765)
 80 | color.AddRGBPoint(1648.01, 0.705882, 0.0156863, 0.14902)
 81 | volume_prop.SetColor(color)
 82 | 
 83 | opacity = vtk.vtkPiecewiseFunction()
 84 | opacity.AllowDuplicateScalarsOn()
 85 | opacity.AddPoint(66.1394, 0)
 86 | opacity.AddPoint(165.784, 0)
 87 | opacity.AddPoint(165.784, 0.244565)
 88 | opacity.AddPoint(423.201, 0.266304)
 89 | opacity.AddPoint(423.201, 0.842391)
 90 | opacity.AddPoint(1648.01, 1)
 91 | volume_prop.SetScalarOpacity(opacity);
 92 | 
 93 | volume = vtk.vtkVolume()
 94 | volume.SetProperty(volume_prop)
 95 | 
 96 | mapper = vtk.vtkGPUVolumeRayCastMapper()
 97 | mapper.SetInputData(image)
 98 | mapper.SetBlendModeToComposite()
 99 | mapper.UseJitteringOn()
100 | mapper.SetVolumetricScatteringBlending(volumetric_scattering_blending)
101 | mapper.SetGlobalIlluminationReach(global_illumination_reach)
102 | volume.SetMapper(mapper)
103 | 
104 | # Set up the lights
105 | ren.ClearLights()
106 | ren.RemoveAllLights()
107 | 
108 | light1 = vtk.vtkLight()
109 | light1.SetIntensity(0.6)
110 | light1.SetPosition(-222.0339, -32.5699, 37.5177)
111 | light1.SetFocalPoint(-118.2287, -51.1928, 103.8297)
112 | 
113 | light2 = vtk.vtkLight()
114 | light2.SetIntensity(0.7)
115 | light2.SetPositional(True)
116 | light2.SetPosition(28.0062, 146.3112, -360.1248)
117 | light2.SetFocalPoint(122.8112, 66.2097, -143.411)
118 | light2.SetConeAngle(48.6)
119 | 
120 | # Ambient light is a headlight
121 | light3 = vtk.vtkLight()
122 | light3.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT)
123 | light3.SetIntensity(0.2)
124 | 
125 | for light in (light1, light2, light3):
126 |     ren.AddLight(light)
127 | 
128 | # Adjust the camera
129 | camera = ren.GetActiveCamera()
130 | camera.SetPosition(278.224, 890.781, -28.4133)
131 | camera.SetFocalPoint(265.61, 273.136, 129.072)
132 | camera.SetViewUp(-0.00327096, -0.247008, -0.969008)
133 | 
134 | ren.AddActor(volume)
135 | 
136 | print("Starting rendering. Click display window and press 'q' to exit")
137 | 
138 | renWin.Render()
139 | iren.Start()
140 | 


--------------------------------------------------------------------------------
/Examples/Python/quilt_image.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | """This example demonstrates creating a quilt image with Python
 4 | 
 5 | A quilt image is a regular image file that can be loaded onto a looking glass
 6 | device via the HoloPlay Studio desktop application, in order to display a
 7 | holographic image on the device.
 8 | """
 9 | 
10 | import vtk
11 | from vtk import vtkRenderingLookingGlass
12 | 
13 | # Create a looking glass render window
14 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
15 | 
16 | # Declare a VTK rendering process, and add it to the window
17 | ren = vtk.vtkRenderer()
18 | renWin.AddRenderer(ren)
19 | 
20 | # Add a cone
21 | cone = vtk.vtkConeSource()
22 | cone.SetRadius(2)
23 | cone.SetHeight(4)
24 | cone.SetCenter(4, 4, 2)
25 | cone.SetDirection(0, 0, 0)
26 | coneMapper = vtk.vtkPolyDataMapper()
27 | coneMapper.SetInputConnection(cone.GetOutputPort())
28 | coneActor = vtk.vtkActor()
29 | coneActor.SetMapper(coneMapper)
30 | ren.AddActor(coneActor)
31 | 
32 | # Initialize the window
33 | renWin.Initialize()
34 | ren.ResetCamera()
35 | ren.GetActiveCamera().SetViewAngle(30)
36 | 
37 | # Must render before writing out the quilt
38 | renWin.Render()
39 | 
40 | # The suffix encodes the tile pattern, such as "_qs5x9"
41 | # This allows software to automatically determine the tile pattern
42 | suffix = renWin.QuiltFileSuffix()
43 | 
44 | # Write out the quilt
45 | renWin.SaveQuilt(f"quilt{suffix}.png")
46 | 


--------------------------------------------------------------------------------
/Examples/Python/quilt_movie.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | """This example demonstrates creating a quilt movie with Python
 4 | 
 5 | A quilt movie is a regular video file that can be loaded onto a looking glass
 6 | device via the HoloPlay Studio desktop application, in order to display a
 7 | holographic video on the device.
 8 | 
 9 | The quilt movie, however, needs to be in a format that HoloPlay Studio can
10 | recognize, such as MP4. VTK will try to write to MP4 if it is available.
11 | Otherwise, the file may need to be converted to MP4 externally before using
12 | it with HoloPlay Studio.
13 | 
14 | Creating quilt movies can take some time because encoding the video frames
15 | can be a slow process. This example demonstrates a rotating cone.
16 | """
17 | 
18 | import math
19 | 
20 | import vtk
21 | 
22 | from vtk import vtkRenderingLookingGlass
23 | 
24 | # Create a looking glass render window
25 | renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()
26 | 
27 | # Declare a VTK rendering process, and add it to the window
28 | ren = vtk.vtkRenderer()
29 | renWin.AddRenderer(ren)
30 | 
31 | # Add a cone
32 | cone = vtk.vtkConeSource()
33 | cone.SetRadius(2)
34 | cone.SetHeight(4)
35 | cone.SetCenter(4, 4, 2)
36 | cone.SetDirection(0, 0, 1)
37 | coneMapper = vtk.vtkPolyDataMapper()
38 | coneMapper.SetInputConnection(cone.GetOutputPort())
39 | coneActor = vtk.vtkActor()
40 | coneActor.SetMapper(coneMapper)
41 | ren.AddActor(coneActor)
42 | 
43 | # Initialize the window
44 | renWin.Initialize()
45 | ren.ResetCamera()
46 | ren.GetActiveCamera().SetViewAngle(30)
47 | 
48 | # The suffix encodes the tile pattern, such as "_qs5x9"
49 | # This allows software to automatically determine the tile pattern
50 | suffix = renWin.QuiltFileSuffix()
51 | 
52 | # Get the movie extension. This will be "mp4" if it is available. Otherwise,
53 | # it may be "avi" or "ogv".
54 | ext = renWin.MovieFileExtension()
55 | 
56 | # Start recording
57 | renWin.StartRecordingQuilt(f"quilt{suffix}.{ext}")
58 | 
59 | # Change the cone direction. Each render will produce a frame in the file.
60 | # This may be slow due to the time required to encode each frame into the
61 | # video file.
62 | num_frames = 30
63 | for i in range(num_frames):
64 |     x = i / num_frames * math.pi
65 |     cone.SetDirection(-math.cos(x), 0, math.sin(x))
66 |     renWin.Render()
67 | 
68 | # Finalize the file
69 | renWin.StopRecordingQuilt()
70 | 


--------------------------------------------------------------------------------
/Examples/Python/vtkLookingGlassPythonDemo.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |  "cells": [
 3 |   {
 4 |    "cell_type": "code",
 5 |    "execution_count": 2,
 6 |    "id": "behind-duplicate",
 7 |    "metadata": {},
 8 |    "outputs": [],
 9 |    "source": [
10 |     "# Import VTK\n",
11 |     "# At this time, you will need to compiled VTK with the Looking Glass module enabled and Python \n",
12 |     "#   wrapping enabled.   Soon we will provide a pip installable version of VTK with the Looking\n",
13 |     "#   Glass module enabled.   For more details, please visit https://vtk.org\n",
14 |     "import vtk\n",
15 |     "\n",
16 |     "from vtk import vtkRenderingLookingGlass\n",
17 |     "\n",
18 |     "# Declare a VTK rendering process\n",
19 |     "ren = vtk.vtkRenderer()\n",
20 |     "\n",
21 |     "# This is the one line to change to use a Looking Glass holographic display\n",
22 |     "#   Use the following line to render to your standard screen:\n",
23 |     "#     renWin = vtk.vtkRenderWindow()\n",
24 |     "#   Use the following line to render to the Looking Glass:  \n",
25 |     "renWin = vtkRenderingLookingGlass.vtkLookingGlassInterface.CreateLookingGlassRenderWindow()\n",
26 |     "\n",
27 |     "# Add the rendering process to the window\n",
28 |     "renWin.AddRenderer(ren)\n",
29 |     "\n",
30 |     "# The mouse controls the position of the camera\n",
31 |     "iren = vtk.vtkRenderWindowInteractor()\n",
32 |     "iren.SetRenderWindow(renWin)\n",
33 |     "\n",
34 |     "# Add some text to the display\n",
35 |     "text = vtk.vtkVectorText()\n",
36 |     "text.SetText(\"Hello VTK!\")\n",
37 |     "textMapper = vtk.vtkPolyDataMapper()\n",
38 |     "textMapper.SetInputConnection(text.GetOutputPort())\n",
39 |     "textActor = vtk.vtkActor()\n",
40 |     "textActor.SetMapper(textMapper)\n",
41 |     "ren.AddActor(textActor)\n",
42 |     "\n",
43 |     "# Position a cone above the text\n",
44 |     "cone = vtk.vtkConeSource()\n",
45 |     "cone.SetRadius(2)\n",
46 |     "cone.SetHeight(4)\n",
47 |     "cone.SetCenter(4,4,2)\n",
48 |     "cone.SetDirection(0,0,1)\n",
49 |     "coneMapper = vtk.vtkPolyDataMapper()\n",
50 |     "coneMapper.SetInputConnection(cone.GetOutputPort())\n",
51 |     "coneActor = vtk.vtkActor()\n",
52 |     "coneActor.SetMapper(coneMapper)\n",
53 |     "ren.AddActor(coneActor)\n",
54 |     "\n",
55 |     "# Initialize the window\n",
56 |     "renWin.Initialize()\n",
57 |     "ren.ResetCamera()\n",
58 |     "ren.GetActiveCamera().SetViewAngle(30)\n",
59 |     "\n",
60 |     "# The mouse controls the camera until \"q\" is pressed to exit\n",
61 |     "iren.Start()"
62 |    ]
63 |   },
64 |   {
65 |    "cell_type": "code",
66 |    "execution_count": null,
67 |    "id": "external-madagascar",
68 |    "metadata": {},
69 |    "outputs": [],
70 |    "source": []
71 |   }
72 |  ],
73 |  "metadata": {
74 |   "kernelspec": {
75 |    "display_name": "Python 3",
76 |    "language": "python",
77 |    "name": "python3"
78 |   },
79 |   "language_info": {
80 |    "codemirror_mode": {
81 |     "name": "ipython",
82 |     "version": 3
83 |    },
84 |    "file_extension": ".py",
85 |    "mimetype": "text/x-python",
86 |    "name": "python",
87 |    "nbconvert_exporter": "python",
88 |    "pygments_lexer": "ipython3",
89 |    "version": "3.8.5"
90 |   }
91 |  },
92 |  "nbformat": 4,
93 |  "nbformat_minor": 5
94 | }
95 | 


--------------------------------------------------------------------------------
/FetchFromUrl.cmake:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | # Before calling this, the following variables must be defined:
 4 | # FETCH_FROM_URL_PROJECT_NAME - a unique name for the project
 5 | # FETCH_FROM_URL_URL - the URL from which to download the project
 6 | # FETCH_FROM_URL_INSTALL_LOCATION - the location to unpack the project
 7 | 
 8 | FetchContent_Populate(${FETCH_FROM_URL_PROJECT_NAME}
 9 |   URL         ${FETCH_FROM_URL_URL}
10 |   SOURCE_DIR  ${FETCH_FROM_URL_INSTALL_LOCATION}
11 |   QUIET
12 |   )
13 | 
14 | message(STATUS "Remote - FETCH_FROM_URL ${FETCH_FROM_URL_PROJECT_NAME} [OK]")
15 | 


--------------------------------------------------------------------------------
/FetchHoloPlayCore.cmake:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | if (UNIX AND NOT APPLE)
 4 |   # Downgrade the version that Linux uses, because the latest version was
 5 |   # built with too new of a glibc version.
 6 |   set(lookingglass_file "HoloPlayCore-0.1.1-Open-20200923.tar.gz")
 7 |   set(lookingglass_md5 b435316fa1f8454ba180e72608c3c28f)
 8 | else ()
 9 |   set(lookingglass_file "LookingGlassCoreSDK-Open-20220819.tgz")
10 |   set(lookingglass_md5 23a2a373c9d1c0f203251dc244f97f79)
11 | endif ()
12 | 
13 | set(proj HoloPlayCore)
14 | set(EP_SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj})
15 | FetchContent_Populate(${proj}
16 |   SOURCE_DIR   ${EP_SOURCE_DIR}
17 |   URL          "https://www.paraview.org/files/dependencies/${lookingglass_file}"
18 |   URL_HASH     "MD5=${lookingglass_md5}"
19 |   QUIET
20 |   )
21 | 
22 | set(${proj}_INCLUDE_DIR "${EP_SOURCE_DIR}/HoloPlayCore/include")
23 | if(APPLE)
24 |   set(_dir "macos")
25 |   set(_prefix "lib")
26 |   set(_ext "dylib")
27 |   set(_rt_ext "dylib")
28 | elseif(UNIX)
29 |   set(_dir "linux")
30 |   set(_prefix "lib")
31 |   set(_ext "so")
32 |   set(_rt_ext "so")
33 | else()
34 |   set(_dir "Win64")
35 |   set(_prefix "")
36 |   set(_ext "lib")
37 |   set(_rt_ext "dll")
38 | endif()
39 | set(_library_dir "${EP_SOURCE_DIR}/HoloPlayCore/dylib/${_dir}")
40 | set(${proj}_LIBRARY "${_library_dir}/${_prefix}HoloPlayCore.${_ext}")
41 | set(${proj}_RUNTIME_LIBRARY "${_library_dir}/${_prefix}HoloPlayCore.${_rt_ext}")
42 | 
43 | message(STATUS "Remote - ${proj} [OK]")
44 | message(STATUS "Remote - ${proj}_INCLUDE_DIR:${${proj}_INCLUDE_DIR}")
45 | message(STATUS "Remote - ${proj}_LIBRARY:${${proj}_LIBRARY}")
46 | message(STATUS "Remote - ${proj}_RUNTIME_LIBRARY:${${proj}_RUNTIME_LIBRARY}")
47 | 


--------------------------------------------------------------------------------
/FetchVTKExternalModule.cmake:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | set(proj VTKExternalModule)
 4 | if (FETCH_${proj}_INSTALL_LOCATION)
 5 |   # The install location can be specified
 6 |   set(EP_SOURCE_DIR "${FETCH_${proj}_INSTALL_LOCATION}")
 7 | else()
 8 |   set(EP_SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj})
 9 | endif()
10 | 
11 | FetchContent_Populate(${proj}
12 |   SOURCE_DIR     ${EP_SOURCE_DIR}
13 |   GIT_REPOSITORY https://github.com/KitwareMedical/VTKExternalModule.git
14 |   GIT_TAG        main
15 |   QUIET
16 |   )
17 | 
18 | message(STATUS "Remote - ${proj} [OK]")
19 | 
20 | set(VTKExternalModule_SOURCE_DIR ${EP_SOURCE_DIR})
21 | message(STATUS "Remote - VTKExternalModule_SOURCE_DIR:${VTKExternalModule_SOURCE_DIR}")
22 | 


--------------------------------------------------------------------------------
/FindHoloPlayCore.cmake:
--------------------------------------------------------------------------------
 1 | find_path(HoloPlayCore_INCLUDE_DIR
 2 |   NAMES HoloPlayCore.h
 3 |   HINTS
 4 |     ${CMAKE_CURRENT_SOURCE_DIR}/../../../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/include
 5 |     ${CMAKE_CURRENT_SOURCE_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/include
 6 |     ${CMAKE_CURRENT_BINARY_DIR}/../../../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/include
 7 |     ${CMAKE_CURRENT_BINARY_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/include
 8 |   DOC "HoloPlayCore.h include directory")
 9 | 
10 | find_library(HoloPlayCore_LIBRARY
11 |   NAMES HoloPlayCore
12 |   HINTS
13 |     ${CMAKE_CURRENT_SOURCE_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/dylib/linux
14 |     ${CMAKE_CURRENT_SOURCE_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/dylib/macos
15 |     ${CMAKE_CURRENT_SOURCE_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/dylib/Win64
16 |     ${CMAKE_CURRENT_BINARY_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/dylib/linux
17 |     ${CMAKE_CURRENT_BINARY_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/dylib/macos
18 |     ${CMAKE_CURRENT_BINARY_DIR}/../HoloPlayCoreSDK-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/dylib/Win64
19 |   DOC "HoloPlayCore library")
20 | 
21 | include(FindPackageHandleStandardArgs)
22 | find_package_handle_standard_args(HoloPlayCore
23 |   REQUIRED_VARS HoloPlayCore_LIBRARY HoloPlayCore_INCLUDE_DIR
24 | )
25 | 
26 | if (HoloPlayCore_FOUND)
27 |   if (NOT HoloPlayCore_RUNTIME_LIBRARY)
28 |     if (WIN32)
29 |       # It should be next to the library
30 |       get_filename_component(_dir ${HoloPlayCore_LIBRARY} DIRECTORY)
31 |       set(HoloPlayCore_RUNTIME_LIBRARY "${_dir}/HoloPlayCore.dll")
32 |       if (NOT EXISTS "${HoloPlayCore_RUNTIME_LIBRARY}")
33 |         message (FATAL_ERROR
34 |           "HoloPlayCore_RUNTIME_LIBRARY must be specified or placed "
35 |           "adjacent to HoloPlayCore_LIBRARY as HoloPlayCore.dll")
36 |       endif ()
37 |     else ()
38 |       # On Linux and Mac, it is the same as the library
39 |       set(HoloPlayCore_RUNTIME_LIBRARY "${HoloPlayCore_LIBRARY}")
40 |     endif ()
41 |   endif ()
42 | 
43 |   set(HoloPlayCore_INCLUDE_DIRS "${HoloPlayCore_INCLUDE_DIR}")
44 |   set(HoloPlayCore_LIBRARIES "${HoloPlayCore_LIBRARY}")
45 |   mark_as_advanced(HoloPlayCore_INCLUDE_DIR)
46 |   mark_as_advanced(HoloPlayCore_LIBRARY)
47 |   mark_as_advanced(HoloPlayCore_RUNTIME_LIBRARY)
48 | 
49 |   if (NOT TARGET HoloPlayCore::HoloPlayCore)
50 |     add_library(HoloPlayCore::HoloPlayCore UNKNOWN IMPORTED)
51 |     set_target_properties(HoloPlayCore::HoloPlayCore
52 |       PROPERTIES
53 |         IMPORTED_LOCATION "${HoloPlayCore_LIBRARY}"
54 |         INTERFACE_INCLUDE_DIRECTORIES "${HoloPlayCore_INCLUDE_DIR}")
55 |   endif ()
56 | endif ()
57 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2020 Kitware, Inc.
 2 | All rights reserved.
 3 | See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 4 | 
 5 |      This software is distributed WITHOUT ANY WARRANTY; without even
 6 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 7 |      PURPOSE.  See the above copyright notice for more information.
 8 | 
 9 | vtkLookingGlassInterface.cxx uses content from the example in HoloPlayCore.
10 | The specific content it uses from HoloPlayCore is distributed under the following license
11 | 
12 | The MIT License (MIT)
13 | 
14 | Copyright (c) 2015 Arthur Sonzogni
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy
17 | of this software and associated documentation files (the "Software"), to
18 | deal in the Software without restriction, including without limitation the
19 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
20 | sell copies of the Software, and to permit persons to whom the Software is
21 | furnished to do so, subject to the following conditions:
22 | 
23 | The above copyright notice and this permission notice shall be included in
24 | all copies or substantial portions of the Software.
25 | 
26 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
31 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
32 | IN THE SOFTWARE.
33 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Looking Glass Device Support
  2 | 
  3 | ## Introduction
  4 | 
  5 | The LookingGlassVTKModule provides support for rendering VTK scenes into
  6 | looking glass devices. Both Python bindings (via the
  7 | [`vtk-lookingglass` package on pip](https://pypi.org/project/vtk-lookingglass/))
  8 | and C++ builds are supported.
  9 | 
 10 | ## Python Support
 11 | The simplest way to get started is by running `pip install vtk-lookingglass`
 12 | and then trying out examples in the `Examples/Python` directory. This should
 13 | work on all major operating systems, and for most modern versions of Python.
 14 | 
 15 | In fact, many [VTK Python Examples](https://kitware.github.io/vtk-examples/site/Python/) can be easily adapted
 16 | to render to the Looking Glass render window by simply swapping out the
 17 | example's render window with one created via
 18 | `vtkLookingGlassInterface.CreateLookingGlassRenderWindow()`.
 19 | 
 20 | ## C++ Support
 21 | For C++ support, there are two main approaches.
 22 | You can create a OS specific Looking Glass render window and use it as you
 23 | would a regular vtkRenderWindow. For an example of this approach please see
 24 | the TestDragon test in `Testing/Cxx/TestDragon.cxx`. The other approach is to
 25 | use the vtkLookingGlassPass as you would normally use a render pass in a
 26 | renderer. For an example of that approach please see
 27 | `Testing\Cxx\TestLookingGlassPass.cxx`.
 28 | 
 29 | ### Build Requirements
 30 | 
 31 | Building this modules requires the Looking Glass Factory's
 32 | `HoloPlayCoreSDK`. You must request a copy of the HoloPlayCoreSDK
 33 | directly from Looking Glass Factory.
 34 | 
 35 | The SDK is described
 36 | [here](https://docs.lookingglassfactory.com/holoplay-core/holoplay-core-sdk).
 37 | 
 38 | You can request access to their SDK
 39 | [here](https://lookingglassfactory.com/software#holoplay-core).
 40 | 
 41 | Access is granted nearly instantaneously.  Their SDK includes dylibs
 42 | (shared libraries) for MacOS, Linux, and Windows (32 and 64bit).
 43 | 
 44 | We recommend installing their SDK at the same level as the
 45 | VTK source directory, so that it can be automatically found by VTK during
 46 | compilation.  For example, if VTK souce is in `/src/VTK` on your system,
 47 | then uncompress the HoloPlaceCoreSDK (which is currently at version 0.2.0) into
 48 | the `/src` directory.   The path to the HoloPlayCoreSDK include directory
 49 | would then be `/src/HoloPlayCore-0.2.0/HoloPlayCoreSDK-master/HoloPlayCore/include`.
 50 | VTK can then automatically find the include and appropriate dylib files
 51 | during CMake configuration of VTK,  otherwise you will have to specify
 52 | the paths to those files manually during CMake configuration.
 53 | 
 54 | ### CMake Configuration of VTK
 55 | 
 56 | When configuring VTK using CMake, enable this remote module and its dependencies by setting
 57 | 1. VTK_MODULE_ENABLE_VTK_RenderingLookingGlass to YES
 58 | 2. VTK_USE_VIDEO_FOR_WINDOWS to ON
 59 | 3. VTK_USE_MICROSOFT_MEDIA_FOUNDATION to ON
 60 | 
 61 | You must also specify
 62 | 1. HoloPlayCore_INCLUDE_DIR
 63 | 2. HoloPlayCore_LIBRARY
 64 | 
 65 | based on where you have installed the HoloPlayCore SDK, if they are not
 66 | automatically found.
 67 | 
 68 | ### Compilation
 69 | 
 70 | With this module enabled in CMake, build VTK as usual for your platform. We
 71 | currently support Windows, OSX, and Linux platforms.
 72 | 
 73 | ### Running VTK applications
 74 | 
 75 | Since the HoloPlayCoreSDK is distribued as shared libraries, their location
 76 | must be known when executing a VTK-based application if that version of
 77 | VTK was compiled with this module enabled.
 78 | 
 79 | We recommend adding the path to the appropriate shared lib to your system's
 80 | PATH/LD_LIBRARY_PATH variables.  They will then be automatically found
 81 | when running VTK applications that were compiled with this module enabled.
 82 | 
 83 | System-level access to the shared libs is also required when running the
 84 | Python wrapped VTK if this module was enabled when it was compiled.
 85 | 
 86 | ### Rendering to a display and generating Quilts
 87 | 
 88 | The key functionality of this module is held in the `vtkLookingGlassInterface`
 89 | class.  It is used by the render window classes and by the render pass
 90 | implementations. This module is even capable of creating distributable quilt
 91 | images even if no Looking Glass hardware is present.
 92 | 
 93 | ### Building and running the C++ tests
 94 | 
 95 | In order to build and run the C++ tests, this module must be built from
 96 | within VTK (see [the required CMake settings](#cmake-configuration-of-vtk))
 97 | with the additional CMake flag `-DVTK_BUILD_TESTING=ON`.
 98 | 
 99 | After building, within the build directory, the tests should be located
100 | in `./bin/vtkLookingGlassCxxTests`, and the test data should be located in
101 | `./ExternalData/Testing/`. The tests may be executed like the following:
102 | 
103 | ```bash
104 | ./bin/vtkLookingGlassCxxTests TestDragon -D ./ExternalData/Testing/ -I
105 | ./bin/vtkLookingGlassCxxTests TestLookingGlassPass -D ./ExternalData/Testing/ -I
106 | ```
107 | 
108 | Where the `-D` flag provides the location of the test data directory,
109 | and the `-I` indiciates that the test should run interactively (otherwise,
110 | the application will render once and close immediately).
111 | 
112 | ## Developement/Bug Reports
113 | 
114 | If you run into issues with this module please submit a bug report at
115 | https://github.com/Kitware/LookingGlassVTKModule/issues
116 | 
117 | ## License
118 | 
119 | See LICENSE file.
120 | 


--------------------------------------------------------------------------------
/Testing/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | vtk_module_test_data(
2 |   Data/dragon.ply)
3 | 
4 | add_subdirectory(Cxx)
5 | 


--------------------------------------------------------------------------------
/Testing/Cxx/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | vtk_add_test_cxx(vtkLookingGlassCxxTests tests
2 |   TestLookingGlassPass.cxx,NO_VALID
3 |   TestDragon.cxx,NO_VALID
4 |   )
5 | 
6 | vtk_test_cxx_executable(vtkLookingGlassCxxTests tests RENDERING_FACTORY)
7 | 


--------------------------------------------------------------------------------
/Testing/Cxx/TestDragon.cxx:
--------------------------------------------------------------------------------
 1 | /*=========================================================================
 2 | 
 3 |   Copyright (c) 2020 Kitware, Inc.
 4 |   All rights reserved.
 5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 6 | 
 7 |      This software is distributed WITHOUT ANY WARRANTY; without even
 8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 9 |      PURPOSE.  See the above copyright notice for more information.
10 | 
11 | =========================================================================*/
12 | 
13 | #include "vtkActor.h"
14 | #include "vtkCamera.h"
15 | #include "vtkNew.h"
16 | #include "vtkOpenGLRenderWindow.h"
17 | #include "vtkPLYReader.h"
18 | #include "vtkPolyDataMapper.h"
19 | #include "vtkProperty.h"
20 | #include "vtkRegressionTestImage.h"
21 | #include "vtkRenderWindowInteractor.h"
22 | #include "vtkRenderer.h"
23 | #include "vtkTestUtilities.h"
24 | 
25 | #include "vtkLookingGlassInterface.h"
26 | 
27 | //------------------------------------------------------------------------------
28 | int TestDragon(int argc, char* argv[])
29 | {
30 |   vtkOpenGLRenderWindow *renderWindow =
31 |     vtkLookingGlassInterface::CreateLookingGlassRenderWindow(0);
32 |   vtkNew<vtkRenderer> renderer;
33 |   vtkNew<vtkRenderWindowInteractor> iren;
34 | 
35 |   vtkNew<vtkActor> actor;
36 |   renderer->SetBackground(0.2, 0.3, 0.4);
37 |   renderWindow->AddRenderer(renderer);
38 |   renderer->AddActor(actor);
39 |   iren->SetRenderWindow(renderWindow);
40 | 
41 |   const char* fileName = vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/dragon.ply");
42 |   vtkNew<vtkPLYReader> reader;
43 |   reader->SetFileName(fileName);
44 | 
45 |   vtkNew<vtkPolyDataMapper> mapper;
46 |   mapper->SetInputConnection(reader->GetOutputPort());
47 |   actor->SetMapper(mapper);
48 |   actor->GetProperty()->SetAmbientColor(0.2, 0.2, 1.0);
49 |   actor->GetProperty()->SetDiffuseColor(1.0, 0.65, 0.7);
50 |   actor->GetProperty()->SetSpecularColor(1.0, 1.0, 1.0);
51 |   actor->GetProperty()->SetSpecular(0.5);
52 |   actor->GetProperty()->SetDiffuse(0.7);
53 |   actor->GetProperty()->SetAmbient(0.5);
54 |   actor->GetProperty()->SetSpecularPower(20.0);
55 |   actor->GetProperty()->SetOpacity(1.0);
56 |   //  actor->GetProperty()->SetRepresentationToWireframe();
57 | 
58 |   renderWindow->Initialize();
59 |   renderer->ResetCamera();
60 |   renderer->GetActiveCamera()->SetViewAngle(30);
61 | 
62 |   int retVal = vtkRegressionTestImage(renderWindow);
63 |   if (retVal == vtkRegressionTester::DO_INTERACTOR)
64 |   {
65 |     iren->Start();
66 |   }
67 | 
68 |   renderWindow->Delete();
69 |   return !retVal;
70 | }
71 | 


--------------------------------------------------------------------------------
/Testing/Cxx/TestLookingGlassPass.cxx:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | // The command line arguments are:
 13 | // -I        => run in interactive mode; unless this is used, the program will
 14 | //              not allow interaction and exit
 15 | 
 16 | #include "vtkActor.h"
 17 | #include "vtkCamera.h"
 18 | #include "vtkLookingGlassInterface.h"
 19 | #include "vtkLookingGlassPass.h"
 20 | #include "vtkNew.h"
 21 | #include "vtkOpenGLRenderer.h"
 22 | #include "vtkPLYReader.h"
 23 | #include "vtkPolyDataMapper.h"
 24 | #include "vtkProperty.h"
 25 | #include "vtkRegressionTestImage.h"
 26 | #include "vtkRenderStepsPass.h"
 27 | #include "vtkRenderWindow.h"
 28 | #include "vtkRenderWindowInteractor.h"
 29 | #include "vtkRenderer.h"
 30 | #include "vtkTestUtilities.h"
 31 | #include "vtkTextureObject.h"
 32 | 
 33 | //------------------------------------------------------------------------------
 34 | int TestLookingGlassPass(int argc, char* argv[])
 35 | {
 36 |   vtkNew<vtkRenderer> renderer;
 37 |   renderer->SetBackground(0.3, 0.4, 0.6);
 38 |   vtkNew<vtkRenderWindow> renderWindow;
 39 |   renderWindow->SetSize(500, 500);
 40 |   renderWindow->AddRenderer(renderer);
 41 |   vtkNew<vtkRenderWindowInteractor> iren;
 42 |   iren->SetRenderWindow(renderWindow);
 43 | 
 44 |   const char* fileName = vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/dragon.ply");
 45 |   vtkNew<vtkPLYReader> reader;
 46 |   reader->SetFileName(fileName);
 47 |   reader->Update();
 48 | 
 49 |   delete[] fileName;
 50 | 
 51 |   vtkNew<vtkPolyDataMapper> mapper;
 52 |   mapper->SetInputConnection(reader->GetOutputPort());
 53 | 
 54 |   // create three dragons
 55 |   {
 56 |     vtkNew<vtkActor> actor;
 57 |     actor->SetMapper(mapper);
 58 |     actor->GetProperty()->SetAmbientColor(1.0, 0.0, 0.0);
 59 |     actor->GetProperty()->SetDiffuseColor(1.0, 0.8, 0.3);
 60 |     actor->GetProperty()->SetSpecular(0.0);
 61 |     actor->GetProperty()->SetDiffuse(0.5);
 62 |     actor->GetProperty()->SetAmbient(0.3);
 63 |     actor->SetPosition(-0.1, 0.0, -0.1);
 64 |     renderer->AddActor(actor);
 65 |   }
 66 | 
 67 |   {
 68 |     vtkNew<vtkActor> actor;
 69 |     actor->SetMapper(mapper);
 70 |     actor->GetProperty()->SetAmbientColor(0.2, 0.2, 1.0);
 71 |     actor->GetProperty()->SetDiffuseColor(0.2, 1.0, 0.8);
 72 |     actor->GetProperty()->SetSpecularColor(1.0, 1.0, 1.0);
 73 |     actor->GetProperty()->SetSpecular(0.2);
 74 |     actor->GetProperty()->SetDiffuse(0.9);
 75 |     actor->GetProperty()->SetAmbient(0.1);
 76 |     actor->GetProperty()->SetSpecularPower(10.0);
 77 |     renderer->AddActor(actor);
 78 |   }
 79 | 
 80 |   {
 81 |     vtkNew<vtkActor> actor;
 82 |     actor->SetMapper(mapper);
 83 |     actor->GetProperty()->SetDiffuseColor(0.5, 0.65, 1.0);
 84 |     actor->GetProperty()->SetSpecularColor(1.0, 1.0, 1.0);
 85 |     actor->GetProperty()->SetSpecular(0.7);
 86 |     actor->GetProperty()->SetDiffuse(0.4);
 87 |     actor->GetProperty()->SetSpecularPower(60.0);
 88 |     actor->SetPosition(0.1, 0.0, 0.1);
 89 |     renderer->AddActor(actor);
 90 |   }
 91 | 
 92 |   renderWindow->SetMultiSamples(8);
 93 | 
 94 |   // create the basic VTK render steps
 95 |   vtkNew<vtkRenderStepsPass> basicPasses;
 96 | 
 97 |   // create the looking glass pass
 98 |   vtkNew<vtkLookingGlassPass> lgpass;
 99 | 
100 |   // initialize it
101 |   lgpass->GetInterface()->Initialize();
102 |   lgpass->SetDelegatePass(basicPasses);
103 | 
104 |   // setup the window based on information from looking glass
105 |   int w, h;
106 |   lgpass->GetInterface()->GetDisplaySize(w, h);
107 |   renderWindow->SetSize(w, h);
108 |   int x, y;
109 |   lgpass->GetInterface()->GetDisplayPosition(x, y);
110 |   renderWindow->SetPosition(x, y);
111 |   renderWindow->BordersOff();
112 | 
113 |   // tell the renderer to use our render pass pipeline
114 |   vtkOpenGLRenderer* glrenderer = vtkOpenGLRenderer::SafeDownCast(renderer);
115 |   glrenderer->SetPass(lgpass);
116 | 
117 |   renderer->GetActiveCamera()->SetPosition(0, 0, 1);
118 |   renderer->GetActiveCamera()->SetFocalPoint(0, 0, 0);
119 |   renderer->GetActiveCamera()->SetViewUp(0, 1, 0);
120 |   renderer->ResetCamera();
121 |   renderer->GetActiveCamera()->Azimuth(15.0);
122 |   renderer->GetActiveCamera()->Zoom(1.8);
123 |   renderWindow->Render();
124 | 
125 |   int retVal = vtkRegressionTestImageThreshold(renderWindow, 15);
126 |   if (retVal == vtkRegressionTester::DO_INTERACTOR)
127 |   {
128 |     iren->Start();
129 |   }
130 | 
131 |   return !retVal;
132 | }
133 | 


--------------------------------------------------------------------------------
/Testing/Python/requirements.txt:
--------------------------------------------------------------------------------
1 | pytest
2 | 


--------------------------------------------------------------------------------
/Testing/Python/test_import.py:
--------------------------------------------------------------------------------
1 | def test_basic_import():
2 |     from vtk import vtkRenderingLookingGlass
3 | 
4 |     # Make sure it has one of the attributes we are expecting
5 |     assert hasattr(vtkRenderingLookingGlass, 'vtkLookingGlassInterface')
6 | 


--------------------------------------------------------------------------------
/lib/vtkmodules/dummy.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Kitware/LookingGlassVTKModule/89b4ded13b653a90c8c8f6c77ecae8af751650ac/lib/vtkmodules/dummy.txt


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = [
 3 |   "cmake",
 4 |   "ninja",
 5 |   "scikit-build",
 6 |   "setuptools>=42",
 7 |   "wheel",
 8 |   "setuptools_scm[toml]>=6.2",
 9 | ]
10 | build-backend = "setuptools.build_meta"
11 | 
12 | [tool.setuptools_scm]
13 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from pathlib import Path
  3 | import platform
  4 | import shutil
  5 | import subprocess
  6 | import sys
  7 | 
  8 | from skbuild import setup
  9 | 
 10 | 
 11 | vtk_looking_glass_module_source_dir = Path(__file__).parent.resolve()
 12 | 
 13 | 
 14 | def auto_download_vtk_wheel_sdk():
 15 |     # Automatically download the VTK wheel SDK based upon the current platform
 16 |     # and python version.
 17 |     # If the download location changes, we may need to change the logic here.
 18 |     # Returns the path to the unpacked SDK.
 19 | 
 20 |     base_url = 'https://vtk.org/files/wheel-sdks/'
 21 |     prefix = 'vtk-wheel-sdk'
 22 |     default_sdk_version = '9.3.20241005.dev0'
 23 |     # The user can set the sdk version via an environment variable
 24 |     sdk_version = os.getenv('VTK_WHEEL_SDK_VERSION', default_sdk_version)
 25 |     py_version_short = ''.join(map(str, sys.version_info[:2]))
 26 | 
 27 |     py_version = f'cp{py_version_short}-cp{py_version_short}'
 28 |     if sys.version_info[:2] < (3, 8):
 29 |         # Need to add 'm' at the end
 30 |         py_version += 'm'
 31 | 
 32 |     platform_suffixes = {
 33 |         'linux': 'linux_x86_64',
 34 |         'darwin': 'macosx_10_10_x86_64',
 35 |         'win32': 'win_amd64',
 36 |     }
 37 | 
 38 |     if sys.platform not in platform_suffixes:
 39 |         raise NotImplementedError(sys.platform)
 40 | 
 41 |     platform_suffix = platform_suffixes[sys.platform]
 42 | 
 43 |     if sys.platform == 'darwin':
 44 |         is_arm = (
 45 |             platform.machine() == 'arm64' or
 46 |             # ARCHFLAGS: see https://github.com/pypa/cibuildwheel/discussions/997
 47 |             os.getenv('ARCHFLAGS') == '-arch arm64'
 48 |         )
 49 |         if is_arm:
 50 |             # It's an arm64 build
 51 |             platform_suffix = 'macosx_11_0_arm64'
 52 | 
 53 |     dir_name = f'{prefix}-{sdk_version}-{py_version}-{platform_suffix}'
 54 |     default_install_path = Path('.').resolve() / f'_deps/{dir_name}'
 55 |     install_path = Path(os.getenv('VTK_WHEEL_SDK_INSTALL_PATH',
 56 |                                   default_install_path))
 57 | 
 58 |     if install_path.exists():
 59 |         # It already exists, just return it
 60 |         return install_path.as_posix()
 61 | 
 62 |     # Need to download it
 63 |     full_name = f'{prefix}-{sdk_version}-{py_version}-{platform_suffix}.tar.xz'
 64 |     url = f'{base_url}{full_name}'
 65 | 
 66 |     script_path = str(vtk_looking_glass_module_source_dir /
 67 |                       'FetchFromUrl.cmake')
 68 | 
 69 |     cmd = [
 70 |         'cmake',
 71 |         f'-DFETCH_FROM_URL_PROJECT_NAME={prefix}',
 72 |         f'-DFETCH_FROM_URL_INSTALL_LOCATION={install_path.as_posix()}',
 73 |         f'-DFETCH_FROM_URL_URL={url}',
 74 |         '-P', script_path,
 75 |     ]
 76 |     subprocess.check_call(cmd)
 77 | 
 78 |     return install_path.as_posix()
 79 | 
 80 | 
 81 | def auto_download_vtk_external_module():
 82 |     # Automatically download the VTKExternalModule repository.
 83 |     # Returns the path to the VTKExternalModule directory.
 84 | 
 85 |     external_module_path = Path('.').resolve() / '_deps/VTKExternalModule'
 86 |     if external_module_path.exists():
 87 |         # It must have already been downloaded. Just return it.
 88 |         return external_module_path.as_posix()
 89 | 
 90 |     # Run the script to download it
 91 |     script_path = str(vtk_looking_glass_module_source_dir /
 92 |                       'FetchVTKExternalModule.cmake')
 93 |     cmd = [
 94 |         'cmake',
 95 |         '-DFETCH_VTKExternalModule_INSTALL_LOCATION=' +
 96 |         external_module_path.as_posix(),
 97 |         '-P', script_path,
 98 |     ]
 99 |     subprocess.check_call(cmd)
100 |     return external_module_path.as_posix()
101 | 
102 | 
103 | vtk_wheel_sdk_path = os.getenv('VTK_WHEEL_SDK_PATH')
104 | if vtk_wheel_sdk_path is None:
105 |     vtk_wheel_sdk_path = auto_download_vtk_wheel_sdk()
106 | 
107 | # Find the cmake dir
108 | cmake_glob = list(Path(vtk_wheel_sdk_path).glob('**/headers/cmake'))
109 | if len(cmake_glob) != 1:
110 |     raise Exception('Unable to find cmake directory')
111 | 
112 | vtk_wheel_sdk_cmake_path = cmake_glob[0]
113 | 
114 | vtk_external_module_path = os.getenv('VTK_EXTERNAL_MODULE_PATH')
115 | if vtk_external_module_path is None:
116 |     # If it was not provided, clone it into a temporary directory
117 |     # Since we are using pyproject.toml, it will get removed automatically
118 |     vtk_external_module_path = auto_download_vtk_external_module()
119 | 
120 | python3_executable = os.getenv('Python3_EXECUTABLE')
121 | if python3_executable is None:
122 |     python3_executable = shutil.which('python')
123 | 
124 | if python3_executable is None:
125 |     msg = 'Unable find python executable, please set Python3_EXECUTABLE'
126 |     raise Exception(msg)
127 | 
128 | cmake_args = [
129 |     '-DVTK_MODULE_NAME:STRING=RenderingLookingGlass',
130 |     f'-DVTK_MODULE_SOURCE_DIR:PATH={vtk_looking_glass_module_source_dir}',
131 |     f'-DVTK_MODULE_CMAKE_MODULE_PATH:PATH={vtk_wheel_sdk_cmake_path}',
132 |     f'-DVTK_DIR:PATH={vtk_wheel_sdk_cmake_path}',
133 |     '-DCMAKE_INSTALL_LIBDIR:STRING=lib',
134 |     f'-DPython3_EXECUTABLE:FILEPATH={python3_executable}',
135 |     '-DVTK_WHEEL_BUILD:BOOL=ON',
136 |     '-S', vtk_external_module_path,
137 | ]
138 | 
139 | if sys.platform == 'linux':
140 |     # We currently have to add this for the render window to get compiled
141 |     cmake_args.append('-DVTK_USE_X:BOOL=ON')
142 | 
143 |     if os.getenv('LINUX_VTK_LOOKING_GLASS_USE_COMPATIBLE_ABI') == '1':
144 |         # If building locally, it is necessary to set this in order to
145 |         # produce a wheel that can be used. Otherwise, the VTK symbols
146 |         # will not match those in the actual VTK wheel.
147 |         cmake_args.append('-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0')
148 | 
149 | elif sys.platform == 'darwin':
150 |     # We currently have to add this for the render window to get compiled
151 |     cmake_args.append('-DVTK_USE_COCOA:BOOL=ON')
152 | 
153 | setup(
154 |     name='vtk-lookingglass',
155 |     description='Looking Glass support for VTK Python.',
156 |     long_description='Looking Glass support for VTK Python.',
157 |     url='',
158 |     author='VTK developers',
159 |     license='MIT',
160 |     classifiers=[
161 |         'Development Status :: 3 - Alpha',
162 |         'License :: OSI Approved :: MIT License',
163 |         'Programming Language :: Python :: 3',
164 |     ],
165 |     keywords='',
166 |     packages=['vtkmodules'],
167 |     package_dir={'vtkmodules': 'lib/vtkmodules'},
168 |     cmake_args=cmake_args,
169 |     install_requires=['vtk==9.3.20241005.dev0'],
170 | )
171 | 


--------------------------------------------------------------------------------
/vtk.module:
--------------------------------------------------------------------------------
 1 | NAME
 2 |   VTK::RenderingLookingGlass
 3 | LIBRARY_NAME
 4 |   vtkRenderingLookingGlass
 5 | LICENSE_FILES
 6 |   LICENSE
 7 | DEPENDS
 8 |   VTK::RenderingOpenGL2
 9 | PRIVATE_DEPENDS
10 |   VTK::IOImage
11 |   VTK::IOMovie
12 | OPTIONAL_DEPENDS
13 |   VTK::IOFFMPEG
14 |   VTK::IOOggTheora
15 | TEST_DEPENDS
16 |   VTK::CommonSystem
17 |   VTK::IOPLY
18 |   VTK::InteractionStyle
19 |   VTK::RenderingVolume
20 |   VTK::TestingCore
21 |   VTK::TestingRendering
22 | DESCRIPTION
23 |   "This module contains support for the LookingGlass 3D display."
24 | 


--------------------------------------------------------------------------------
/vtkCocoaLookingGlassRenderWindow.h:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | /**
 13 |  * @class   vtkCocoaLookingGlassRenderWindow
 14 |  * @brief   LookingGlass rendering window
 15 |  *
 16 |  * A drop in replacement on Windows for vtkOpenGLRenderWindow that will
 17 |  * render to a LookingGlass display
 18 |  */
 19 | 
 20 | #ifndef vtkCocoaLookingGlassRenderWindow_h
 21 | #define vtkCocoaLookingGlassRenderWindow_h
 22 | 
 23 | #include "vtkCocoaRenderWindow.h"
 24 | #include "vtkRenderingLookingGlassModule.h" // For export macro
 25 | 
 26 | class vtkLookingGlassInterface;
 27 | 
 28 | class VTKRENDERINGLOOKINGGLASS_EXPORT vtkCocoaLookingGlassRenderWindow : public vtkCocoaRenderWindow
 29 | {
 30 | public:
 31 |   static vtkCocoaLookingGlassRenderWindow* New();
 32 |   vtkTypeMacro(vtkCocoaLookingGlassRenderWindow, vtkCocoaRenderWindow);
 33 | 
 34 |   // Get the LookingGlassInterface being used by this window.
 35 |   vtkGetObjectMacro(Interface, vtkLookingGlassInterface);
 36 | 
 37 |   /**
 38 |    * Get the size (width and height) of the rendering window.
 39 |    * We override so that durnig the render process we can return
 40 |    * a size of the render framebuffer as opposed to the final
 41 |    * buffer.
 42 |    */
 43 |   int* GetSize() VTK_SIZEHINT(2) override;
 44 | 
 45 |   /**
 46 |    * Free up any graphics resources associated with this window
 47 |    * a value of nullptr means the context may already be destroyed
 48 |    */
 49 |   void ReleaseGraphicsResources(vtkWindow*) override;
 50 | 
 51 |   /**
 52 |    * Give the window a chance to be created on the Looking Glass display.
 53 |    */
 54 |   void Initialize() override;
 55 | 
 56 |   /**
 57 |    * Set index of the Looking Glass device on which this window should appear.
 58 |    */
 59 |   void SetLGDeviceIndex(int index);
 60 | 
 61 |   /**
 62 |    * Save a quilt to a PNG file
 63 |    */
 64 |   void SaveQuilt(const char* fileName);
 65 | 
 66 |   /**
 67 |    * Start recording a quilt
 68 |    */
 69 |   void StartRecordingQuilt(const char* fileName);
 70 | 
 71 |   /**
 72 |    * Stop recording a quilt
 73 |    */
 74 |   void StopRecordingQuilt();
 75 | 
 76 |   /**
 77 |    * Get the movie extension that should be used for quilt movies
 78 |    */
 79 |   static const char* MovieFileExtension();
 80 | 
 81 |   /**
 82 |    * Get the quilt file suffix as a string. The suffix encodes the number of
 83 |    * tiles in the width and the height. For example, if the quilt file name
 84 |    * is "quilt_qs5x9.png", the suffix is "_qs5x9", and it means that the quilt
 85 |    * is 5 tiles wide and 9 tiles high.
 86 |    */
 87 |   std::string QuiltFileSuffix() const;
 88 | 
 89 |   /**
 90 |    * Turn on/off use of near and far clipping limits.
 91 |    */
 92 |   void SetUseClippingLimits(bool b);
 93 | 
 94 |   /**
 95 |    * Turn on/off use of near and far clipping limits.
 96 |    */
 97 |   bool GetUseClippingLimits() const;
 98 |   vtkBooleanMacro(UseClippingLimits, bool);
 99 | 
100 |   /**
101 |    * Set/Get limit for the ratio of the far clipping plane to the focal
102 |    * distance. This is a mechanism to limit parallex and resulting
103 |    * ghosting when using the looking glass display. The typical value
104 |    * should be around 1.2.
105 |    */
106 |   void SetFarClippingLimit(double d);
107 | 
108 |   /**
109 |    * Set/Get limit for the ratio of the far clipping plane to the focal
110 |    * distance. This is a mechanism to limit parallex and resulting
111 |    * ghosting when using the looking glass display. The typical value
112 |    * should be around 1.2.
113 |    */
114 |   double GetFarClippingLimit() const;
115 | 
116 |   /**
117 |    * Set/Get limit for the ratio of the near clipping plane to the focal
118 |    * distance. This is a mechanism to limit parallex and resulting
119 |    * ghosting when using the looking glass display. The typical value
120 |    * should be around 0.8.
121 |    */
122 |   void SetNearClippingLimit(double d);
123 | 
124 |   /**
125 |    * Set/Get limit for the ratio of the near clipping plane to the focal
126 |    * distance. This is a mechanism to limit parallex and resulting
127 |    * ghosting when using the looking glass display. The typical value
128 |    * should be around 0.8.
129 |    */
130 |   double GetNearClippingLimit() const;
131 | 
132 |   /**
133 |    * Check if a movie quilt is currently being recorded.
134 |    */
135 |   bool IsRecordingQuilt() const;
136 | 
137 |   /**
138 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
139 |    * increases.
140 |    */
141 |   void SetDeviceIndex(int i) override;
142 | 
143 |   /**
144 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
145 |    * increases.
146 |    */
147 |   int GetDeviceIndex() const;
148 | 
149 |   /**
150 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
151 |    * generated for a device that is not connected in the future.
152 |    */
153 |   void SetDeviceType(const std::string &t);
154 | 
155 |   /**
156 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
157 |    * generated for a device that is not connected in the future.
158 |    */
159 |   std::string GetDeviceType() const;
160 | 
161 |   /**
162 |    * Returns a vector of available device types.
163 |    */
164 |   static std::vector<std::string> GetDeviceTypes();
165 | 
166 | protected:
167 |   vtkCocoaLookingGlassRenderWindow();
168 |   ~vtkCocoaLookingGlassRenderWindow() override;
169 | 
170 |   vtkLookingGlassInterface* Interface = nullptr;
171 | 
172 |   void InitializeInterface();
173 | 
174 |   void DoStereoRender() override;
175 |   bool InStereoRender;
176 | 
177 | private:
178 |   vtkCocoaLookingGlassRenderWindow(const vtkCocoaLookingGlassRenderWindow&) = delete;
179 |   void operator=(const vtkCocoaLookingGlassRenderWindow&) = delete;
180 | };
181 | 
182 | #endif
183 | 


--------------------------------------------------------------------------------
/vtkCocoaLookingGlassRenderWindow.mm:
--------------------------------------------------------------------------------
 1 | /*=========================================================================
 2 | 
 3 |   Copyright (c) 2020 Kitware, Inc.
 4 |   All rights reserved.
 5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 6 | 
 7 |      This software is distributed WITHOUT ANY WARRANTY; without even
 8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 9 |      PURPOSE.  See the above copyright notice for more information.
10 | 
11 | =========================================================================*/
12 | #include "vtkCocoaLookingGlassRenderWindow.h"
13 | 
14 | #define className vtkCocoaLookingGlassRenderWindow
15 | #include "vtkLookingGlassRenderWindowImpl.h"
16 | 
17 | #import <Cocoa/Cocoa.h>
18 | #import <Foundation/Foundation.h>
19 | #import <IOKit/graphics/IOGraphicsLib.h>
20 | #include "HoloPlayCore.h"
21 | 
22 | //------------------------------------------------------------------------------
23 | void vtkCocoaLookingGlassRenderWindow::Initialize()
24 | {
25 |   // Limited to device 0 fow now
26 |   char buf[1000];
27 |   int deviceIndex = this->Interface->GetDeviceIndex();
28 |   hpc_GetDeviceHDMIName(deviceIndex, buf, 1000);
29 |   std::string deviceName(buf);
30 | 
31 |   // Default to display 1, assuming the LG display is the only auxilliary display
32 |   int displayId = 1;
33 | 
34 |   // Explicitly look for the LG display
35 |   int screenIndex = 0;
36 |   NSArray *screens = [NSScreen screens];
37 |   for (NSScreen *screen in screens)
38 |   {
39 |     int currentDisplayID = [[[screen deviceDescription] valueForKey:@"NSScreenNumber"] intValue];
40 |     NSDictionary *deviceInfo =
41 |       (NSDictionary *)CFBridgingRelease(IODisplayCreateInfoDictionary(CGDisplayIOServicePort(currentDisplayID),
42 |                                                                       kIODisplayOnlyPreferredName));
43 |     NSDictionary *localizedNames = [deviceInfo objectForKey:[NSString stringWithUTF8String:kDisplayProductName]];
44 | 
45 |     NSString *screenName = nil;
46 |     if ([localizedNames count] > 0) {
47 |       screenName = [localizedNames objectForKey:[[localizedNames allKeys] objectAtIndex:0]];
48 |       std::string screenNameString = std::string([screenName UTF8String]);
49 |       if (screenNameString == deviceName)
50 |       {
51 |         displayId = screenIndex;
52 |         break;
53 |       }
54 |     }
55 |     ++screenIndex;
56 |   }
57 |   this->SetDisplayId(&displayId);
58 | 
59 |   this->Superclass::Initialize();
60 | }
61 | 


--------------------------------------------------------------------------------
/vtkLookingGlassInterface.cxx:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 | Program:   Visualization Toolkit
  4 | Module:    vtkLookingGlassInterface.cxx
  5 | 
  6 |   Copyright (c) 2020 Kitware, Inc.
  7 |   All rights reserved.
  8 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  9 | 
 10 |      This software is distributed WITHOUT ANY WARRANTY; without even
 11 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 12 |      PURPOSE.  See the above copyright notice for more information.
 13 | 
 14 | This software uses content from HoloPlayCore, which is distributed under the
 15 | following license:
 16 | 
 17 | The MIT License (MIT)
 18 | 
 19 | Copyright (c) 2015 Arthur Sonzogni
 20 | 
 21 | Permission is hereby granted, free of charge, to any person obtaining a copy
 22 | of this software and associated documentation files (the "Software"), to
 23 | deal in the Software without restriction, including without limitation the
 24 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 25 | sell copies of the Software, and to permit persons to whom the Software is
 26 | furnished to do so, subject to the following conditions:
 27 | 
 28 | The above copyright notice and this permission notice shall be included in
 29 | all copies or substantial portions of the Software.
 30 | 
 31 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 32 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 33 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 34 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 35 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 36 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 37 | IN THE SOFTWARE.
 38 | 
 39 | =========================================================================*/
 40 | #include "vtkLookingGlassInterface.h"
 41 | 
 42 | #include "HoloPlayCore.h"
 43 | #include "HoloPlayShadersOpen.h"
 44 | 
 45 | #include "vtkCamera.h"
 46 | #include "vtkDataArray.h"
 47 | #include "vtkImageData.h"
 48 | #include "vtkMath.h"
 49 | #include "vtkNew.h"
 50 | #include "vtkObjectFactory.h"
 51 | #include "vtkOpenGLFramebufferObject.h"
 52 | #include "vtkOpenGLQuadHelper.h"
 53 | #include "vtkOpenGLRenderWindow.h"
 54 | #include "vtkOpenGLShaderCache.h"
 55 | #include "vtkOpenGLState.h"
 56 | #include "vtkPNGWriter.h"
 57 | #include "vtkPixelBufferObject.h"
 58 | #include "vtkPixelExtent.h"
 59 | #include "vtkPixelTransfer.h"
 60 | #include "vtkPointData.h"
 61 | #include "vtkRendererCollection.h"
 62 | #include "vtkShaderProgram.h"
 63 | #include "vtkTextureObject.h"
 64 | #include "vtkVectorOperators.h"
 65 | 
 66 | #include "vtk_glad.h"
 67 | 
 68 | #include "vtkRenderingOpenGLConfigure.h"
 69 | 
 70 | #ifdef WIN32
 71 | #include "vtkWin32LookingGlassRenderWindow.h"
 72 | #endif
 73 | #ifdef VTK_USE_X
 74 | #include "vtkXLookingGlassRenderWindow.h"
 75 | #endif
 76 | #ifdef VTK_USE_COCOA
 77 | #include "vtkCocoaLookingGlassRenderWindow.h"
 78 | #endif
 79 | 
 80 | #ifdef VTK_USE_MICROSOFT_MEDIA_FOUNDATION
 81 | // Use the MP4 writer on Windows
 82 | #include "vtkMP4Writer.h"
 83 | using MovieWriterClass = vtkMP4Writer;
 84 | static const char* MovieExtension = "mp4";
 85 | #elif VTK_MODULE_ENABLE_VTK_IOFFMPEG
 86 | // If not Windows, use FFMPEG if it is available
 87 | #include "vtkFFMPEGWriter.h"
 88 | using MovieWriterClass = vtkFFMPEGWriter;
 89 | static const char* MovieExtension = "avi";
 90 | #else
 91 | // Otherwise, use Ogg Theora.
 92 | #include "vtkOggTheoraWriter.h"
 93 | using MovieWriterClass = vtkOggTheoraWriter;
 94 | static const char* MovieExtension = "ogv";
 95 | #endif
 96 | 
 97 | //------------------------------------------------------------------------------
 98 | const char* vtkLookingGlassInterface::MovieFileExtension()
 99 | {
100 |   return MovieExtension;
101 | }
102 | 
103 | //------------------------------------------------------------------------------
104 | vtkOpenGLRenderWindow* vtkLookingGlassInterface::CreateLookingGlassRenderWindow(int deviceIndex)
105 | {
106 | #ifdef WIN32
107 |   auto renWin = vtkWin32LookingGlassRenderWindow::New();
108 | #endif
109 | #ifdef VTK_USE_X
110 |   auto renWin = vtkXLookingGlassRenderWindow::New();
111 | #endif
112 | #ifdef VTK_USE_COCOA
113 |   auto renWin = vtkCocoaLookingGlassRenderWindow::New();
114 | #endif
115 | 
116 |   renWin->SetLGDeviceIndex(deviceIndex);
117 | 
118 |   return renWin;
119 | }
120 | 
121 | vtkStandardNewMacro(vtkLookingGlassInterface);
122 | 
123 | //------------------------------------------------------------------------------
124 | vtkLookingGlassInterface::vtkLookingGlassInterface()
125 |   : Connected(false)
126 |   , DeviceIndex(0)
127 |   , UseClippingLimits(false)
128 |   , FarClippingLimit(1.2)
129 |   , NearClippingLimit(0.8)
130 |   , ViewAngle(30.0)
131 |   , FinalBlend(nullptr)
132 |   , QuiltBlend(nullptr)
133 |   , Initialized(false)
134 |   , RenderFramebuffer(nullptr)
135 |   , QuiltFramebuffer(nullptr)
136 |   , QuiltQuality(1)
137 |   , IsRecording(false)
138 |   , AdjustCameraAspectRatio(1.777)
139 |   , MovieImageBuffer(nullptr)
140 |   , MovieImageData(nullptr)
141 |   , MovieWriter(nullptr)
142 | {
143 |   this->DisplayPosition[0] = 0;
144 |   this->DisplayPosition[1] = 0;
145 |   this->DisplaySize[0] = 1280;
146 |   this->DisplaySize[1] = 720;
147 |   this->QuiltTexture = vtkTextureObject::New();
148 | }
149 | 
150 | //------------------------------------------------------------------------------
151 | vtkLookingGlassInterface::~vtkLookingGlassInterface()
152 | {
153 |   if (this->IsRecording)
154 |   {
155 |     this->StopRecordingQuilt();
156 |   }
157 | 
158 |   if (this->RenderFramebuffer != nullptr)
159 |   {
160 |     vtkErrorMacro(<< "Render Framebuffer should have been deleted in "
161 |                      "ReleaseGraphicsResources().");
162 |   }
163 |   if (this->QuiltFramebuffer != nullptr)
164 |   {
165 |     vtkErrorMacro(<< "QuiltFramebuffer should have been deleted in "
166 |                      "ReleaseGraphicsResources().");
167 |   }
168 |   if (this->QuiltTexture != nullptr)
169 |   {
170 |     this->QuiltTexture->Delete();
171 |     this->QuiltTexture = nullptr;
172 |   }
173 |   if (this->FinalBlend != nullptr)
174 |   {
175 |     delete this->FinalBlend;
176 |     this->FinalBlend = nullptr;
177 |   }
178 |   if (this->QuiltBlend != nullptr)
179 |   {
180 |     delete this->QuiltBlend;
181 |     this->QuiltBlend = nullptr;
182 |   }
183 | 
184 |   if (this->MovieImageBuffer != nullptr)
185 |   {
186 |     this->MovieImageBuffer->Delete();
187 |     this->MovieImageBuffer = nullptr;
188 |   }
189 | 
190 |   if (this->MovieImageData != nullptr)
191 |   {
192 |     this->MovieImageData->Delete();
193 |     this->MovieImageData = nullptr;
194 |   }
195 | 
196 |   if (this->MovieWriter != nullptr)
197 |   {
198 |     this->MovieWriter->Delete();
199 |     this->MovieWriter = nullptr;
200 |   }
201 | 
202 |   // must tear down the message pipe before shut down the app
203 |   if (this->Connected)
204 |   {
205 |     hpc_CloseApp();
206 |     this->Connected = false;
207 |   }
208 | }
209 | 
210 | vtkLookingGlassInterface::DeviceSettings::DeviceSettings(const std::string& name, int quiltWidth,
211 |   int quiltHeight, int quiltTilesColumns, int quiltTilesRows, double aspectRatio)
212 | {
213 |   this->Name = name;
214 |   this->QuiltSize[0] = quiltWidth;
215 |   this->QuiltSize[1] = quiltHeight;
216 |   this->QuiltTiles[0] = quiltTilesColumns;
217 |   this->QuiltTiles[1] = quiltTilesRows;
218 |   this->AspectRatio = aspectRatio;
219 | }
220 | 
221 | std::map<std::string, vtkLookingGlassInterface::DeviceSettings>
222 | vtkLookingGlassInterface::GetSettingsByDevice()
223 | {
224 | 
225 |   static std::map<std::string, DeviceSettings> settingsByDevice = {};
226 | 
227 |   if (settingsByDevice.empty())
228 |   {
229 |     settingsByDevice["standard"] = DeviceSettings("Looking Glass 8.9\"",
230 |       2048, 2048, // QuiltSize
231 |       4, 8,       // QuiltTiles
232 |       1.6         // AspectRatio
233 |     );
234 |     settingsByDevice["portrait"] = DeviceSettings("Looking Glass Portrait",
235 |       3360, 3360, // QuiltSize
236 |       8, 6,       // QuiltTiles
237 |       0.75        // AspectRatio
238 |     );
239 |     settingsByDevice["large"] = DeviceSettings("Looking Glass 16\"",
240 |       4096, 4096, // QuiltSize
241 |       5, 9,       // QuiltTiles
242 |       1.777       // AspectRatio
243 |     );
244 |     settingsByDevice["8k"] = DeviceSettings("Looking Glass 32\"",
245 |       4096 * 2, 4096 * 2, // QuiltSize
246 |       5, 9,               // QuiltTiles
247 |       1.777               // AspectRatio
248 |     );
249 |     settingsByDevice["8k_gen2"] = DeviceSettings("Looking Glass 32\" (gen2)",
250 |       4096 * 2, 4096 * 2, // QuiltSize
251 |       5, 9,               // QuiltTiles
252 |       1.777               // AspectRatio
253 |     );
254 |     settingsByDevice["65"] = DeviceSettings("Looking Glass 65\"",
255 |       8192, 8192,  // QuiltSize
256 |       8, 9,        // QuiltTiles
257 |       1.777        // AspectRatio
258 |     );
259 |   }
260 | 
261 |   return settingsByDevice;
262 | }
263 | 
264 | vtkLookingGlassInterface::DeviceSettings vtkLookingGlassInterface::GetSettingsForDevice(
265 |   const std::string deviceType)
266 | {
267 |   return GetSettingsByDevice().at(deviceType);
268 | }
269 | 
270 | vtkLookingGlassInterface::DeviceTypes vtkLookingGlassInterface::GetDevices()
271 | {
272 |   vtkLookingGlassInterface::DeviceTypes types;
273 |   for (auto const device : GetSettingsByDevice())
274 |   {
275 |     types.push_back(std::make_pair(device.first, device.second.Name));
276 |   }
277 | 
278 |   return types;
279 | }
280 | 
281 | vtkOpenGLRenderWindow* vtkLookingGlassInterface::CreateSharedLookingGlassRenderWindow(
282 |   vtkOpenGLRenderWindow* srcWin)
283 | {
284 |   vtkOpenGLRenderWindow* renWin = static_cast<vtkOpenGLRenderWindow*>(vtkOpenGLRenderWindow::New());
285 |   this->Initialize();
286 |   renWin->SetSharedRenderWindow(srcWin);
287 |   renWin->SetSize(this->DisplaySize[0], this->DisplaySize[1]);
288 |   renWin->SetPosition(this->DisplayPosition[0], this->DisplayPosition[1]);
289 |   renWin->BordersOff();
290 | 
291 |   return renWin;
292 | }
293 | 
294 | bool vtkLookingGlassInterface::GetLookingGlassInfo()
295 | {
296 |   hpc_client_error errco = hpc_InitializeApp("VTK", hpc_LICENSE_NONCOMMERCIAL);
297 |   if (errco)
298 |   {
299 |     std::string errstr;
300 |     switch (errco)
301 |     {
302 |       case hpc_CLIERR_NOSERVICE:
303 |         errstr = "HoloPlay Service not running";
304 |         break;
305 |       case hpc_CLIERR_SERIALIZEERR:
306 |         errstr = "Client message could not be serialized";
307 |         break;
308 |       case hpc_CLIERR_VERSIONERR:
309 |         errstr = "Incompatible version of HoloPlay Service";
310 |         break;
311 |       case hpc_CLIERR_PIPEERROR:
312 |         errstr = "Interprocess pipe broken";
313 |         break;
314 |       case hpc_CLIERR_SENDTIMEOUT:
315 |         errstr = "Interprocess pipe send timeout";
316 |         break;
317 |       case hpc_CLIERR_RECVTIMEOUT:
318 |         errstr = "Interprocess pipe receive timeout";
319 |         break;
320 |       default:
321 |         errstr = "Unknown error";
322 |         break;
323 |     }
324 |     vtkErrorMacro("Client access error (code = " << errco << "): " << errstr);
325 |     return false;
326 |   }
327 | 
328 |   char buf[1000];
329 |   hpc_GetHoloPlayCoreVersion(buf, 1000);
330 |   vtkDebugMacro("HoloPlay Core version " << buf);
331 |   hpc_GetHoloPlayServiceVersion(buf, 1000);
332 |   vtkDebugMacro("HoloPlay Service version " << buf);
333 |   int num_displays = hpc_GetNumDevices();
334 |   vtkDebugMacro("connected device count: " << num_displays);
335 |   if (num_displays < 1)
336 |   {
337 |     return false;
338 |   }
339 |   for (int i = 0; i < num_displays; ++i)
340 |   {
341 |     vtkDebugMacro("Device information for display %d:\n" << i);
342 |     hpc_GetDeviceHDMIName(i, buf, 1000);
343 |     vtkDebugMacro("\tDevice name: " << buf);
344 |     hpc_GetDeviceType(i, buf, 1000);
345 |     vtkDebugMacro("\tDevice type: " << buf);
346 |     vtkDebugMacro("\nWindow parameters for display: " << i);
347 |     vtkDebugMacro(
348 |       "\tPosition: " << hpc_GetDevicePropertyWinX(i) << ", " << hpc_GetDevicePropertyWinY(i));
349 |     vtkDebugMacro(
350 |       "\tSize: " << hpc_GetDevicePropertyScreenW(i) << ", " << hpc_GetDevicePropertyScreenH(i));
351 |     vtkDebugMacro("\tAspect ratio: " << hpc_GetDevicePropertyDisplayAspect(i));
352 |     vtkDebugMacro("Shader uniforms for display " << i);
353 |     vtkDebugMacro("\tpitch: " << hpc_GetDevicePropertyPitch(i));
354 |     vtkDebugMacro("\ttilt: " << hpc_GetDevicePropertyTilt(i));
355 |     vtkDebugMacro("\tcenter: " << hpc_GetDevicePropertyCenter(i));
356 |     vtkDebugMacro("\tsubp: " << hpc_GetDevicePropertySubp(i));
357 |     vtkDebugMacro("\tviewCone: " << hpc_GetDevicePropertyFloat(i, "/calibration/viewCone/value"));
358 |     vtkDebugMacro("\tfringe: " << hpc_GetDevicePropertyFringe(i));
359 |     vtkDebugMacro("\tRI: " << hpc_GetDevicePropertyRi(i)
360 |                            << "\n \tBI: " << hpc_GetDevicePropertyBi(i)
361 |                            << "\tinvView: " << hpc_GetDevicePropertyInvView(i));
362 |   }
363 | 
364 |   return true;
365 | }
366 | 
367 | void vtkLookingGlassInterface::SetupQuiltSettings(const DeviceSettings& settings)
368 | {
369 |   std::copy(settings.QuiltSize, settings.QuiltSize + 2, this->QuiltSize);
370 |   std::copy(settings.QuiltTiles, settings.QuiltTiles + 2, this->QuiltTiles);
371 |   this->AdjustCameraAspectRatio = settings.AspectRatio;
372 | };
373 | 
374 | // set up the quilt settings
375 | void vtkLookingGlassInterface::SetupQuiltSettings(int preset)
376 | {
377 |   // there are 3 presets:
378 |   switch (preset)
379 |   {
380 |     case 0:
381 |     { // standard
382 |       this->SetupQuiltSettings("standard");
383 |     }
384 |     break;
385 |     default:
386 |     case 1:
387 |     { // hires - i assume this is large or pro?
388 |       this->SetupQuiltSettings("large");
389 |     }
390 |     break;
391 |     case 2:
392 |     { // 8k
393 |       this->SetupQuiltSettings("8k");
394 |     }
395 |     break;
396 |   }
397 | }
398 | 
399 | // set up quilt settings for a given device
400 | void vtkLookingGlassInterface::SetupQuiltSettings(const std::string& deviceType)
401 | {
402 |   auto byDevice = this->GetSettingsByDevice();
403 |   if (byDevice.count(deviceType))
404 |   {
405 |     auto deviceSettings = byDevice[deviceType];
406 |     this->SetupQuiltSettings(deviceSettings);
407 |   }
408 |   else
409 |   {
410 |     // Issue warning and default to "large" device
411 |     vtkWarningMacro(
412 |       "Unrecognized device type: '" << deviceType << "', defaulting to setting for 'large' device");
413 |     auto deviceSettings = GetSettingsForDevice("large");
414 |     this->SetupQuiltSettings(deviceSettings);
415 |   }
416 | }
417 | 
418 | //------------------------------------------------------------------------------
419 | // Initialize the rendering window, must be called first
420 | void vtkLookingGlassInterface::Initialize(void)
421 | {
422 |   if (this->Initialized)
423 |   {
424 |     return;
425 |   }
426 | 
427 |   if (!GetLookingGlassInfo())
428 |   {
429 |     // must tear down the message pipe before shut down the app
430 |     hpc_CloseApp();
431 |     this->Connected = false;
432 |   }
433 |   else
434 |   {
435 |     this->Connected = true;
436 | 
437 |     // get the viewcone here, which is used as a const
438 |     this->ViewAngle = hpc_GetDevicePropertyFloat(this->DeviceIndex, "/calibration/viewCone/value");
439 | 
440 |     // get the window coordinate from the uniform
441 |     this->DisplaySize[0] = hpc_GetDevicePropertyScreenW(this->DeviceIndex);
442 |     this->DisplaySize[1] = hpc_GetDevicePropertyScreenH(this->DeviceIndex);
443 |     this->DisplayPosition[0] = hpc_GetDevicePropertyWinX(this->DeviceIndex);
444 |     this->DisplayPosition[1] = hpc_GetDevicePropertyWinY(this->DeviceIndex);
445 | 
446 |     // Default the adjust camera aspect ratio to the device's aspect ratio
447 |     this->AdjustCameraAspectRatio =
448 |       static_cast<double>(this->DisplaySize[0]) / this->DisplaySize[1];
449 | 
450 |     // get the device type if one hasn't been set
451 |     if (this->DeviceType.empty())
452 |     {
453 |       char buf[100];
454 |       hpc_GetDeviceType(this->DeviceIndex, buf, 100);
455 |       this->DeviceType = buf;
456 |     }
457 |   }
458 | 
459 |   // If we still don't have a device type default to "large"
460 |   if (this->DeviceType.empty())
461 |   {
462 |     vtkWarningMacro("No Looking Glass device attached defaulting to 'large'");
463 |     this->DeviceType = "large";
464 |   }
465 | 
466 |   this->SetupQuiltSettings(this->DeviceType);
467 | 
468 |   this->NumberOfTiles = this->QuiltTiles[0] * this->QuiltTiles[1];
469 | 
470 |   // compute the render size we need
471 |   this->RenderSize[0] = this->QuiltSize[0] / this->QuiltTiles[0];
472 |   this->RenderSize[1] = this->QuiltSize[1] / this->QuiltTiles[1];
473 | 
474 |   this->Initialized = true;
475 | }
476 | 
477 | //=========================================================
478 | // set up the camera with the view and the shader of the rendering object
479 | void vtkLookingGlassInterface::AdjustCamera(vtkCamera* cam, int currentViewIndex)
480 | {
481 |   // The standard model Looking Glass screen is roughly 4.75" vertically. If we
482 |   // assume the average viewing distance for a user sitting at their desk is
483 |   // about 36", our field of view should be about 14°. There is no correct
484 |   // answer, as it all depends on your expected user's distance from the Looking
485 |   // Glass, but we've found the most success using this figure.
486 |   // const float fov = vtkMath::RadiansFromDegrees(14.0f);
487 |   // float cameraDistance = -cameraSize / tan(fov / 2.0f);
488 | 
489 |   int totalViews = this->QuiltTiles[0] * this->QuiltTiles[1];
490 |   double offsetAngle = (currentViewIndex / (totalViews - 1.0f) - 0.5f) *
491 |     vtkMath::RadiansFromDegrees(this->ViewAngle); // start at -viewCone * 0.5 and go
492 |                                                   // up to viewCone * 0.5
493 | 
494 |   double cameraDistance = cam->GetDistance();
495 | 
496 |   double offset =
497 |     cameraDistance * tan(offsetAngle); // calculate the offset that the camera should move
498 | 
499 |   vtkVector3d vup;
500 |   cam->GetViewUp(vup.GetData());
501 |   vtkVector3d vpn;
502 |   cam->GetViewPlaneNormal(vpn.GetData());
503 |   vtkVector3d vright = vup.Cross(vpn);
504 |   vtkVector3d tmp;
505 |   cam->GetPosition(tmp.GetData());
506 |   tmp = tmp + vright * offset;
507 |   cam->SetPosition(tmp.GetData());
508 |   cam->GetFocalPoint(tmp.GetData());
509 |   tmp = tmp + vright * offset;
510 |   cam->SetFocalPoint(tmp.GetData());
511 | 
512 |   double aspectRatio = this->AdjustCameraAspectRatio;
513 |   double camViewAngle = vtkMath::RadiansFromDegrees(cam->GetViewAngle());
514 |   double winSize = aspectRatio * cameraDistance * tan(camViewAngle / 2.0);
515 | 
516 |   cam->SetWindowCenter(-offset / winSize, 0);
517 | }
518 | 
519 | void vtkLookingGlassInterface::DrawLightField(
520 |   vtkOpenGLRenderWindow* renWin, vtkTextureObject* copyTO)
521 | {
522 |   if (copyTO->GetHandle() != this->QuiltTexture->GetHandle())
523 |   {
524 |     copyTO->AssignToExistingTexture(this->QuiltTexture->GetHandle(), GL_TEXTURE_2D);
525 |   }
526 |   this->DrawLightFieldInternal(renWin, copyTO);
527 | }
528 | 
529 | // draw the quilt onto the currently bound framebuffer
530 | void vtkLookingGlassInterface::DrawLightField(vtkOpenGLRenderWindow* renWin)
531 | {
532 |   this->DrawLightFieldInternal(renWin, this->QuiltTexture);
533 | }
534 | 
535 | void vtkLookingGlassInterface::DrawLightFieldInternal(
536 |   vtkOpenGLRenderWindow* renWin, vtkTextureObject* tex)
537 | {
538 |   // Simple default vertex and fragment shaders
539 |   static const std::string defaultVS =
540 |     R"***(
541 |     //VTK::System::Dec
542 |     in vec4 ndCoordIn;
543 |     in vec2 texCoordIn;
544 |     out vec2 texCoords;
545 |     void main()
546 |     {
547 |       gl_Position = ndCoordIn;
548 |       texCoords = texCoordIn;
549 |     }
550 |   )***";
551 | 
552 |   static const std::string defaultFS =
553 |     R"***(
554 |       //VTK::System::Dec
555 | 
556 |       in vec2 texCoords;
557 |       out vec4 fragColor;
558 |       uniform sampler2D screenTex;
559 |       void main()
560 |       {
561 |     		fragColor = vec4(texture(screenTex, texCoords.xy).rgb, 1.0);
562 |       }
563 |   )***";
564 | 
565 |   vtkOpenGLQuadHelper* blend = nullptr;
566 | 
567 |   if (!this->Connected)
568 |   {
569 |     // Use the QuiltBlend
570 |     if (!this->QuiltBlend)
571 |     {
572 |       this->QuiltBlend = new vtkOpenGLQuadHelper(renWin, defaultVS.c_str(), defaultFS.c_str(), "");
573 |     }
574 |     else
575 |     {
576 |       renWin->GetShaderCache()->ReadyShaderProgram(this->QuiltBlend->Program);
577 |     }
578 |     blend = this->QuiltBlend;
579 |   }
580 |   else
581 |   {
582 |     // Use the FinalBlend
583 |     if (!this->FinalBlend)
584 |     {
585 |       // just add the standard VTK header to the fragment shader
586 |       std::string fshader = "//VTK::System::Dec\n\n";
587 |       fshader += hpc_LightfieldFragShaderGLSL;
588 |       this->FinalBlend = new vtkOpenGLQuadHelper(renWin, defaultVS.c_str(), fshader.c_str(), "");
589 |     }
590 |     else
591 |     {
592 |       renWin->GetShaderCache()->ReadyShaderProgram(this->FinalBlend->Program);
593 |     }
594 |     blend = this->FinalBlend;
595 |   }
596 | 
597 |   if (blend->Program)
598 |   {
599 |     auto& prog = blend->Program;
600 | 
601 |     if (this->Connected)
602 |     {
603 |       // prog->SetUniformi("debug", 1);
604 |       prog->SetUniformf("pitch", hpc_GetDevicePropertyPitch(this->DeviceIndex));
605 |       prog->SetUniformf("tilt", hpc_GetDevicePropertyTilt(this->DeviceIndex));
606 |       prog->SetUniformf("center", hpc_GetDevicePropertyCenter(this->DeviceIndex));
607 |       prog->SetUniformi("invView", hpc_GetDevicePropertyInvView(this->DeviceIndex));
608 |       prog->SetUniformi("quiltInvert", 0);
609 |       prog->SetUniformf("subp", hpc_GetDevicePropertySubp(this->DeviceIndex));
610 |       prog->SetUniformi("ri", hpc_GetDevicePropertyRi(this->DeviceIndex));
611 |       prog->SetUniformi("bi", hpc_GetDevicePropertyBi(this->DeviceIndex));
612 |       prog->SetUniformf("displayAspect", hpc_GetDevicePropertyDisplayAspect(this->DeviceIndex));
613 |       prog->SetUniformf("quiltAspect", hpc_GetDevicePropertyDisplayAspect(this->DeviceIndex));
614 |       prog->SetUniformi("overscan", 0);
615 | 
616 |       float tmp3[3];
617 |       tmp3[0] = this->QuiltTiles[0];
618 |       tmp3[1] = this->QuiltTiles[1];
619 |       tmp3[2] = this->NumberOfTiles;
620 |       prog->SetUniform3f("tile", tmp3);
621 | 
622 |       float tmp2[2];
623 |       tmp2[0] = this->RenderSize[0] * this->QuiltTiles[0] / (float)this->QuiltSize[0];
624 |       tmp2[1] = this->RenderSize[1] * this->QuiltTiles[1] / (float)this->QuiltSize[1];
625 |       prog->SetUniform2f("viewPortion", tmp2);
626 |     }
627 | 
628 |     renWin->GetState()->vtkglDepthMask(GL_FALSE);
629 |     renWin->GetState()->vtkglDisable(GL_DEPTH_TEST);
630 | 
631 |     renWin->GetState()->vtkglViewport(0, 0, this->DisplaySize[0], this->DisplaySize[1]);
632 |     renWin->GetState()->vtkglScissor(0, 0, this->DisplaySize[0], this->DisplaySize[1]);
633 | 
634 |     tex->Activate();
635 |     prog->SetUniformi("screenTex", tex->GetTextureUnit());
636 | 
637 |     // draw the full screen quad using the special shader
638 |     blend->Render();
639 | 
640 |     tex->Deactivate();
641 | 
642 |     renWin->GetState()->vtkglDepthMask(GL_TRUE);
643 |   }
644 | }
645 | 
646 | void vtkLookingGlassInterface::ReleaseGraphicsResources(vtkWindow* w)
647 | {
648 |   if (this->QuiltTexture && w)
649 |   {
650 |     this->QuiltTexture->ReleaseGraphicsResources(w);
651 |   }
652 |   if (this->RenderFramebuffer)
653 |   {
654 |     if (w)
655 |     {
656 |       this->RenderFramebuffer->ReleaseGraphicsResources(w);
657 |     }
658 |     this->RenderFramebuffer->UnRegister(this);
659 |     this->RenderFramebuffer = nullptr;
660 |   }
661 |   if (this->QuiltFramebuffer)
662 |   {
663 |     if (w)
664 |     {
665 |       this->QuiltFramebuffer->ReleaseGraphicsResources(w);
666 |     }
667 |     this->QuiltFramebuffer->UnRegister(this);
668 |     this->QuiltFramebuffer = nullptr;
669 |   }
670 |   if (this->FinalBlend)
671 |   {
672 |     delete this->FinalBlend;
673 |     this->FinalBlend = nullptr;
674 |   }
675 |   if (this->QuiltBlend)
676 |   {
677 |     delete this->QuiltBlend;
678 |     this->QuiltBlend = nullptr;
679 |   }
680 | }
681 | 
682 | // gets/creates the framebuffers
683 | void vtkLookingGlassInterface::GetFramebuffers(vtkOpenGLRenderWindow* renWin,
684 |   vtkOpenGLFramebufferObject*& renderFramebuffer, vtkOpenGLFramebufferObject*& quiltFramebuffer)
685 | {
686 |   auto ostate = renWin->GetState();
687 | 
688 |   if (this->QuiltFramebuffer == nullptr)
689 |   {
690 |     ostate->PushFramebufferBindings();
691 |     this->RenderFramebuffer = vtkOpenGLFramebufferObject::New();
692 |     this->RenderFramebuffer->SetContext(renWin);
693 |     this->RenderFramebuffer->Bind();
694 | 
695 |     // verify that our multisample setting doe snot exceed the hardware
696 |     int multiSamples = 0;
697 |     if (renWin->GetMultiSamples())
698 |     {
699 |       int msamples = 0;
700 |       ostate->vtkglGetIntegerv(GL_MAX_SAMPLES, &msamples);
701 |       if (multiSamples > msamples)
702 |       {
703 |         multiSamples = msamples;
704 |       }
705 |       if (multiSamples == 1)
706 |       {
707 |         multiSamples = 0;
708 |       }
709 |     }
710 |     this->RenderFramebuffer->PopulateFramebuffer(this->RenderSize[0], this->RenderSize[1],
711 |       true,                 // textures
712 |       1, VTK_UNSIGNED_CHAR, // 1 color buffer uchar
713 |       true, 32,             // depth buffer
714 |       multiSamples, renWin->GetStencilCapable() != 0 ? true : false);
715 | 
716 |     this->QuiltFramebuffer = vtkOpenGLFramebufferObject::New();
717 |     this->QuiltFramebuffer->SetContext(renWin);
718 |     this->QuiltFramebuffer->Bind();
719 | 
720 |     this->QuiltTexture->SetContext(renWin);
721 |     this->QuiltTexture->Allocate2D(this->QuiltSize[0], this->QuiltSize[1], 4, VTK_UNSIGNED_CHAR);
722 |     this->QuiltTexture->SetMinificationFilter(vtkTextureObject::Linear);
723 |     this->QuiltTexture->SetMagnificationFilter(vtkTextureObject::Linear);
724 |     this->QuiltTexture->SetWrapS(vtkTextureObject::Repeat);
725 |     this->QuiltTexture->SetWrapT(vtkTextureObject::Repeat);
726 | 
727 |     this->QuiltFramebuffer->AddColorAttachment(0, this->QuiltTexture);
728 |     this->QuiltFramebuffer->ActivateDrawBuffer(0);
729 |     this->QuiltFramebuffer->ActivateReadBuffer(0);
730 | 
731 |     ostate->PopFramebufferBindings();
732 |   }
733 | 
734 |   // make sure the size is correct, nop if size is unchanged
735 |   this->RenderFramebuffer->Resize(this->RenderSize[0], this->RenderSize[1]);
736 |   this->QuiltFramebuffer->Resize(this->QuiltSize[0], this->QuiltSize[1]);
737 | 
738 |   renderFramebuffer = this->RenderFramebuffer;
739 |   quiltFramebuffer = this->QuiltFramebuffer;
740 | }
741 | 
742 | // Simply compute and return the position in the quilt for a tile
743 | void vtkLookingGlassInterface::GetTilePosition(int tile, int pos[2])
744 | {
745 |   pos[0] = (tile % this->QuiltTiles[0]) * this->RenderSize[0];
746 |   pos[1] = (tile / this->QuiltTiles[0]) * this->RenderSize[1];
747 | }
748 | 
749 | void vtkLookingGlassInterface::RenderQuilt(vtkOpenGLRenderWindow* rw,
750 |   vtkRendererCollection* renderers, std::function<void(void)>* renderFunc)
751 | {
752 |   if (!renderers)
753 |   {
754 |     // If no renderers are provided, default to all on the render window
755 |     renderers = rw->GetRenderers();
756 |   }
757 | 
758 |   vtkCollectionSimpleIterator rsit;
759 | 
760 |   // loop over the tiles, render,and blit
761 |   vtkOpenGLFramebufferObject* renderFramebuffer;
762 |   vtkOpenGLFramebufferObject* quiltFramebuffer;
763 |   this->GetFramebuffers(rw, renderFramebuffer, quiltFramebuffer);
764 | 
765 |   auto ostate = rw->GetState();
766 | 
767 |   ostate->PushFramebufferBindings();
768 |   renderFramebuffer->Bind(GL_READ_FRAMEBUFFER);
769 | 
770 |   int renderSize[2];
771 |   this->GetRenderSize(renderSize);
772 | 
773 |   int tcount = this->GetNumberOfTiles();
774 | 
775 |   // save the original camera settings
776 |   vtkRenderer* aren;
777 |   std::vector<vtkCamera*> Cameras;
778 |   for (renderers->InitTraversal(rsit); (aren = renderers->GetNextRenderer(rsit));)
779 |   {
780 |     // Ugly piece of code - we need to know if the camera already
781 |     // exists or not. If it does not yet exist, we must reset the
782 |     // camera here - otherwise it will never be done (missing its
783 |     // oppportunity to be reset in the Render method of the
784 |     // vtkRenderer because it will already exist by that point...)
785 |     if (!aren->IsActiveCameraCreated())
786 |     {
787 |       aren->ResetCamera();
788 |     }
789 |     auto oldCam = aren->GetActiveCamera();
790 |     oldCam->SetLeftEye(1);
791 |     oldCam->Register(rw);
792 |     Cameras.push_back(oldCam);
793 |     vtkNew<vtkCamera> newCam;
794 |     aren->SetActiveCamera(newCam);
795 |   }
796 | 
797 |   // loop over all the tiles and render then and blit them to the quilt
798 |   for (int tile = 0; tile < tcount; ++tile)
799 |   {
800 |     renderFramebuffer->Bind(GL_DRAW_FRAMEBUFFER);
801 |     ostate->vtkglViewport(0, 0, renderSize[0], renderSize[1]);
802 |     ostate->vtkglScissor(0, 0, renderSize[0], renderSize[1]);
803 | 
804 |     int count = 0;
805 |     for (renderers->InitTraversal(rsit); (aren = renderers->GetNextRenderer(rsit)); ++count)
806 |     {
807 |       // adjust camera
808 |       vtkCamera* cam = aren->GetActiveCamera();
809 |       cam->DeepCopy(Cameras[count]);
810 |       this->AdjustCamera(cam, tile);
811 | 
812 |       // limit the clipping range to limit parallax
813 |       if (this->GetUseClippingLimits())
814 |       {
815 |         double* cRange = cam->GetClippingRange();
816 |         double cameraDistance = cam->GetDistance();
817 | 
818 |         double nearClippingLimit = this->GetNearClippingLimit();
819 |         double farClippingLimit = this->GetFarClippingLimit();
820 | 
821 |         double newRange[2];
822 |         newRange[0] = cRange[0];
823 |         newRange[1] = cRange[1];
824 |         if (cRange[0] < cameraDistance * nearClippingLimit)
825 |         {
826 |           newRange[0] = cameraDistance * nearClippingLimit;
827 |         }
828 |         if (cRange[1] > cameraDistance * farClippingLimit)
829 |         {
830 |           newRange[1] = cameraDistance * farClippingLimit;
831 |         }
832 |         cam->SetClippingRange(newRange);
833 |       }
834 |     }
835 | 
836 |     if (renderFunc)
837 |     {
838 |       (*renderFunc)();
839 |     }
840 |     else
841 |     {
842 |       renderers->Render();
843 |     }
844 | 
845 |     quiltFramebuffer->Bind(GL_DRAW_FRAMEBUFFER);
846 | 
847 |     int destPos[2];
848 |     this->GetTilePosition(tile, destPos);
849 | 
850 |     // blit to quilt
851 |     ostate->vtkglViewport(destPos[0], destPos[1], renderSize[0], renderSize[1]);
852 |     ostate->vtkglScissor(destPos[0], destPos[1], renderSize[0], renderSize[1]);
853 |     glBlitFramebuffer(0, 0, renderSize[0], renderSize[1], destPos[0], destPos[1],
854 |       destPos[0] + renderSize[0], destPos[1] + renderSize[1], GL_COLOR_BUFFER_BIT, GL_LINEAR);
855 |   }
856 |   ostate->PopFramebufferBindings();
857 | 
858 |   // restore the original camera settings
859 |   int count = 0;
860 |   for (renderers->InitTraversal(rsit); (aren = renderers->GetNextRenderer(rsit)); ++count)
861 |   {
862 |     aren->SetActiveCamera(Cameras[count]);
863 |     Cameras[count]->Delete();
864 |   }
865 | 
866 |   if (this->IsRecording)
867 |   {
868 |     // Write out a movie frame if we are recording
869 |     this->WriteQuiltMovieFrame();
870 |   }
871 | }
872 | 
873 | void vtkLookingGlassInterface::SaveQuilt(const char* fileName)
874 | {
875 |   vtkSmartPointer<vtkPixelBufferObject> pbo = this->QuiltTexture->Download();
876 | 
877 |   vtkNew<vtkImageData> buffer;
878 |   buffer->SetDimensions(this->QuiltSize[0], this->QuiltSize[1], 1);
879 |   buffer->AllocateScalars(VTK_UNSIGNED_CHAR, 4);
880 | 
881 |   vtkPixelExtent ext(this->QuiltSize[0], this->QuiltSize[1]);
882 |   auto* srcData = pbo->MapPackedBuffer();
883 |   auto* destData = buffer->GetScalarPointer(0, 0, 0);
884 |   vtkPixelTransfer::Blit(ext, 4, VTK_UNSIGNED_CHAR, srcData, VTK_UNSIGNED_CHAR, destData);
885 |   pbo->UnmapPackedBuffer();
886 | 
887 |   // Convert to 3 components.
888 |   // Getting rid of the alpha component eliminates the transparent background.
889 |   vtkNew<vtkImageData> image;
890 |   image->SetDimensions(this->QuiltSize[0], this->QuiltSize[1], 1);
891 |   image->AllocateScalars(VTK_UNSIGNED_CHAR, 3);
892 | 
893 |   auto oldArray = buffer->GetPointData()->GetScalars();
894 |   auto newArray = image->GetPointData()->GetScalars();
895 |   for (int i = 0; i < 3; ++i)
896 |   {
897 |     newArray->CopyComponent(i, oldArray, i);
898 |   }
899 | 
900 |   vtkNew<vtkPNGWriter> writer;
901 |   writer->SetFileName(fileName);
902 |   writer->SetInputData(image);
903 |   writer->Write();
904 | }
905 | 
906 | std::string vtkLookingGlassInterface::QuiltFileSuffix() const
907 | {
908 |   std::string w = std::to_string(this->QuiltTiles[0]);
909 |   std::string h = std::to_string(this->QuiltTiles[1]);
910 |   return "_qs" + w + "x" + h;
911 | }
912 | 
913 | void vtkLookingGlassInterface::StartRecordingQuilt(const char* fileName)
914 | {
915 |   if (this->IsRecording)
916 |   {
917 |     // Already recording
918 |     return;
919 |   }
920 | 
921 |   if (!this->MovieImageBuffer)
922 |   {
923 |     this->MovieImageBuffer = vtkImageData::New();
924 |   }
925 | 
926 |   if (!this->MovieImageData)
927 |   {
928 |     this->MovieImageData = vtkImageData::New();
929 |   }
930 | 
931 |   if (!this->MovieWriter)
932 |   {
933 |     this->MovieWriter = MovieWriterClass::New();
934 |   }
935 | 
936 |   auto buffer = this->MovieImageBuffer;
937 |   auto image = this->MovieImageData;
938 |   auto writer = this->MovieWriter;
939 | 
940 |   buffer->SetDimensions(this->QuiltSize[0], this->QuiltSize[1], 1);
941 |   buffer->AllocateScalars(VTK_UNSIGNED_CHAR, 4);
942 | 
943 |   image->SetDimensions(this->QuiltSize[0], this->QuiltSize[1], 1);
944 |   image->AllocateScalars(VTK_UNSIGNED_CHAR, 3);
945 | 
946 |   writer->SetInputData(image);
947 |   writer->SetFileName(fileName);
948 |   writer->Start();
949 | 
950 |   this->IsRecording = true;
951 | }
952 | 
953 | void vtkLookingGlassInterface::WriteQuiltMovieFrame()
954 | {
955 |   if (!this->IsRecording)
956 |   {
957 |     return;
958 |   }
959 | 
960 |   auto buffer = this->MovieImageBuffer;
961 |   auto image = this->MovieImageData;
962 |   auto writer = this->MovieWriter;
963 | 
964 |   vtkSmartPointer<vtkPixelBufferObject> pbo = this->QuiltTexture->Download();
965 | 
966 |   vtkPixelExtent ext(this->QuiltSize[0], this->QuiltSize[1]);
967 |   auto* srcData = pbo->MapPackedBuffer();
968 |   auto* destData = buffer->GetScalarPointer(0, 0, 0);
969 |   vtkPixelTransfer::Blit(ext, 4, VTK_UNSIGNED_CHAR, srcData, VTK_UNSIGNED_CHAR, destData);
970 |   pbo->UnmapPackedBuffer();
971 | 
972 |   // Ogg Theora (and possibly other movie writers as well) assume the
973 |   // data will be 3-component. Thus, we have to convert it to 3-component
974 |   // or else the movie writer will not work properly.
975 |   auto oldArray = buffer->GetPointData()->GetScalars();
976 |   auto newArray = image->GetPointData()->GetScalars();
977 |   for (int i = 0; i < 3; ++i)
978 |   {
979 |     newArray->CopyComponent(i, oldArray, i);
980 |   }
981 | 
982 |   writer->Write();
983 | }
984 | 
985 | void vtkLookingGlassInterface::StopRecordingQuilt()
986 | {
987 |   if (!this->IsRecording)
988 |   {
989 |     // Not recording...
990 |     return;
991 |   }
992 | 
993 |   auto writer = this->MovieWriter;
994 | 
995 |   writer->End();
996 | 
997 |   this->IsRecording = false;
998 | }
999 | 


--------------------------------------------------------------------------------
/vtkLookingGlassInterface.h:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | /**
 13 |  * @class   vtkLookingGlassInterface
 14 |  * @brief   Class to interface with LookingGlass hardware.
 15 |  *
 16 |  * This class contains a collection of methods to fascilitate
 17 |  * rendering to a LookingGlass display.
 18 |  */
 19 | 
 20 | #ifndef vtkLookingGlassInterface_h
 21 | #define vtkLookingGlassInterface_h
 22 | 
 23 | #include "vtkDeprecation.h"
 24 | #include "vtkObject.h"
 25 | #include "vtkRenderingLookingGlassModule.h" // For export macro
 26 | #include <map>
 27 | #include <vector>
 28 | 
 29 | #include <functional>
 30 | 
 31 | class vtkCamera;
 32 | class vtkGenericMovieWriter;
 33 | class vtkImageData;
 34 | class vtkOpenGLFramebufferObject;
 35 | class vtkOpenGLQuadHelper;
 36 | class vtkOpenGLRenderWindow;
 37 | class vtkRendererCollection;
 38 | class vtkTextureObject;
 39 | class vtkWindow;
 40 | 
 41 | class VTKRENDERINGLOOKINGGLASS_EXPORT vtkLookingGlassInterface : public vtkObject
 42 | {
 43 | public:
 44 |   static vtkLookingGlassInterface* New();
 45 |   vtkTypeMacro(vtkLookingGlassInterface, vtkObject);
 46 | 
 47 |   // create an OpenGLRenderWindow suitable for looking glass
 48 |   // just a convenience method to handle the OS specific subclasses
 49 |   // in a generic manner. The deviceIndex argument specifies the
 50 |   // index of the LookingGlass device on which the window should be placed
 51 |   // (presently supported only on macOS).
 52 |   static vtkOpenGLRenderWindow* CreateLookingGlassRenderWindow(int deviceIndex = 0);
 53 | 
 54 |   // Get the display posiiton for the looking glass device
 55 |   vtkGetVector2Macro(DisplayPosition, int);
 56 | 
 57 |   // Get the size in pixels of the looking glass device
 58 |   vtkGetVector2Macro(DisplaySize, int);
 59 | 
 60 |   // get the size of the images that should be rendered to the quilt
 61 |   vtkGetVector2Macro(RenderSize, int);
 62 | 
 63 |   // get the size of the quilt to be used
 64 |   vtkGetVector2Macro(QuiltSize, int);
 65 | 
 66 |   // get the number of tiles on the quilt in the X, Y
 67 |   vtkGetVector2Macro(QuiltTiles, int);
 68 | 
 69 |   // Get the total number of tiles for the quilt
 70 |   // Just QuiltTiles[0] * QuiltTiles[1]
 71 |   vtkGetMacro(NumberOfTiles, int);
 72 | 
 73 |   vtkGetMacro(ViewAngle, double);
 74 | 
 75 |   // The aspect ratio to use when adjusting the camera to render the tiles.
 76 |   // This is modifiable so that we can generate quilts for devices that have
 77 |   // a different aspect ratio than the device currently connected.
 78 |   vtkGetMacro(AdjustCameraAspectRatio, double);
 79 | 
 80 |   // Return the position in pixels in the quilt for that tile
 81 |   void GetTilePosition(int tile, int pos[2]);
 82 | 
 83 |   // Must be called first
 84 |   void Initialize();
 85 | 
 86 |   // Adjust a camera's settings to be correct for the view of the specified
 87 |   // tile. The camera passed in should have your centered view. It will be
 88 |   // modified to correspond to the view for that provided tile.
 89 |   void AdjustCamera(vtkCamera* cam, int tile);
 90 | 
 91 |   // Render the Quilt (LightField) to the currently bound Framebuffer
 92 |   void DrawLightField(vtkOpenGLRenderWindow* rw);
 93 | 
 94 |   // Render the Quilt (LightField) to the currently bound Framebuffer by using a
 95 |   // provided texture. This is for the case where you are using two
 96 |   // opengl context's and using the texture handle to pass between them
 97 |   void DrawLightField(vtkOpenGLRenderWindow* rw, vtkTextureObject* copyTO);
 98 | 
 99 |   // Get, and create if needed, framebuffers to be used for rendering and
100 |   // constructing the quilt. These will have sizes based on the LookingGlass
101 |   // settings.
102 |   void GetFramebuffers(vtkOpenGLRenderWindow* rw, vtkOpenGLFramebufferObject*& renderFramebuffer,
103 |     vtkOpenGLFramebufferObject*& quiltFramebuffer);
104 | 
105 |   /**
106 |    * Release graphics resources and ask components to release their own
107 |    * resources.
108 |    * \pre w_exists: w!=0
109 |    */
110 |   void ReleaseGraphicsResources(vtkWindow* w);
111 | 
112 |   //@{
113 |   /**
114 |    * Set/Get the quality of the quilt to use. 0 is the lowest setting
115 |    * and 2 is the highest. Higher settings require more texture memory.
116 |    * The default setting is 1.
117 |    */
118 |   VTK_DEPRECATED_IN_9_2_0("Quality is now based on device type.")
119 |   vtkSetMacro(QuiltQuality, int);
120 |   VTK_DEPRECATED_IN_9_2_0("Quality is now based on device type.")
121 |   vtkGetMacro(QuiltQuality, int);
122 |   //@}
123 | 
124 |   //@{
125 |   /**
126 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
127 |    * increases.
128 |    */
129 |   vtkSetMacro(DeviceIndex, int);
130 |   vtkGetMacro(DeviceIndex, int);
131 |   //@}
132 | 
133 |   //@{
134 |   /**
135 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
136 |    * generated for a device that is not connected in the future.
137 |    */
138 |   vtkSetMacro(DeviceType, std::string);
139 |   vtkGetMacro(DeviceType, std::string);
140 |   //@}
141 | 
142 |   //@{
143 |   /**
144 |    * Turn on/off use of near and far clipping limits.
145 |    */
146 |   vtkSetMacro(UseClippingLimits, bool);
147 |   vtkGetMacro(UseClippingLimits, bool);
148 |   vtkBooleanMacro(UseClippingLimits, bool);
149 |   //@}
150 | 
151 |   //@{
152 |   /**
153 |    * Set/Get limit for the ratio of the far clipping plane to the focal
154 |    * distance. This is a mechanism to limit parallex and resulting
155 |    * ghosting when using the looking glass display. The typical value
156 |    * should be around 1.2.
157 |    */
158 |   vtkSetMacro(FarClippingLimit, double);
159 |   vtkGetMacro(FarClippingLimit, double);
160 |   //@}
161 | 
162 |   //@{
163 |   /**
164 |    * Set/Get limit for the ratio of the near clipping plane to the focal
165 |    * distance. This is a mechanism to limit parallex and resulting
166 |    * ghosting when using the looking glass display. The typical value
167 |    * should be around 0.8.
168 |    */
169 |   vtkSetMacro(NearClippingLimit, double);
170 |   vtkGetMacro(NearClippingLimit, double);
171 |   //@}
172 | 
173 |   // helper method to return a window set to share the opengl lists with
174 |   // the provided window. Such as when you want a desktop window and a
175 |   // looking glass window to mirror it.
176 |   vtkOpenGLRenderWindow* CreateSharedLookingGlassRenderWindow(vtkOpenGLRenderWindow* srcWin);
177 | 
178 |   // Render the quilt using the provided render window.
179 |   // The `renderers` argument defaults to all renderers on the render window,
180 |   // but can be provided to use only a subset of the renderers.
181 |   // The `renderFunc` is an optional function to use for rendering instead of
182 |   // the `Render()` function on the renderers. This is important when custom
183 |   // rendering is required, such as in a vtkRenderPass, like the
184 |   // vtkLookingGlassPass.
185 |   // Note that you may need to modify the size of the render window to be that
186 |   // of the vtkLookingGlassInterface::GetRenderSize() before calling this
187 |   // function.
188 |   void RenderQuilt(vtkOpenGLRenderWindow* rw, vtkRendererCollection* renderers = nullptr,
189 |     std::function<void(void)>* renderFunc = nullptr);
190 | 
191 |   /**
192 |    * Save the quilt currently displayed in the render window as a PNG file.
193 |    * The quilt can be loaded into HoloPlay Studio to run the Looking Glass
194 |    * device in stand-alone mode.
195 |    */
196 |   void SaveQuilt(const char* fileName);
197 | 
198 |   VTK_DEPRECATED_IN_9_2_0("The render window argument is no longer used and should be removed")
199 |   void SaveQuilt(vtkOpenGLRenderWindow* rw, const char* fileName) { this->SaveQuilt(fileName); }
200 | 
201 |   /**
202 |    * Get the extension of the movie file that will be written if the
203 |    * user records a video quilt.
204 |    * This will be "mp4", "avi", or "ogg", depending on what is available
205 |    * from the VTK build.
206 |    * MP4 will be used if it is available, since it is the only one that
207 |    * HoloPlay Studio can read in.
208 |    * If one of the other formats are used, the user will have to use external
209 |    * software to convert it to a format that HoloPlay Studio can read.
210 |    */
211 |   static const char* MovieFileExtension();
212 | 
213 |   /**
214 |    * Get the quilt file suffix as a string. The suffix encodes the number of
215 |    * tiles in the width and the height. For example, if the quilt file name
216 |    * is "quilt_qs5x9.png", the suffix is "_qs5x9", and it means that the quilt
217 |    * is 5 tiles wide and 9 tiles high.
218 |    */
219 |   std::string QuiltFileSuffix() const;
220 | 
221 |   /**
222 |    * Check if a movie quilt is currently being recorded.
223 |    */
224 |   bool IsRecordingQuilt() const { return this->IsRecording; }
225 | 
226 |   /**
227 |    * Start recording the quilt from the render window display and save it as
228 |    * a movie file. WriteQuiltMovieFrame() should be called each time a
229 |    * frame should be written. This happens automatically each time `RenderQuilt()`
230 |    * is called, which results in a frame being written for every render. But
231 |    * WriteQuiltMovieFrame() may be called additional times to write extra frames.
232 |    *
233 |    * The quilt can be loaded into HoloPlay Studio to run the Looking Glass
234 |    * device in stand-alone mode, although the user may need to convert the
235 |    * video file into a format that HoloPlay Studio can read (such as MP4).
236 |    */
237 |   void StartRecordingQuilt(const char* fileName);
238 | 
239 |   VTK_DEPRECATED_IN_9_2_0("The render window argument is no longer used and should be removed")
240 |   void StartRecordingQuilt(vtkOpenGLRenderWindow* rw, const char* fileName)
241 |   {
242 |     this->StartRecordingQuilt(fileName);
243 |   }
244 | 
245 |   /**
246 |    * Write a frame to the movie file. StartRecordingQuilt() must have been
247 |    * called previously. This function is called automatically in
248 |    * `RenderQuilt()` while a movie is being recorded, but it can be called
249 |    * additional times to write extra frames.
250 |    */
251 |   void WriteQuiltMovieFrame();
252 | 
253 |   /**
254 |    * Stop recording the quilt to finish the movie file.
255 |    *
256 |    * The quilt can be loaded into HoloPlay Studio to run the Looking Glass
257 |    * device in stand-alone mode, although the user may need to convert the
258 |    * video file into a format that HoloPlay Studio can read.
259 |    */
260 |   void StopRecordingQuilt();
261 | 
262 |   using DeviceTypes = std::vector<std::pair<std::string, std::string>>;
263 | 
264 |   /**
265 |    * Returns vector of pairs with the available device types.
266 |    */
267 |   static DeviceTypes GetDevices();
268 | 
269 | protected:
270 |   /**
271 |    * struct to hold device specfic settings.
272 |    */
273 |   struct DeviceSettings
274 |   {
275 |     DeviceSettings(const std::string& name, int quiltWidth, int quiltHeight, int quiltTilesColumns,
276 |       int quiltTilesRows, double aspectRatio);
277 |     DeviceSettings() = default;
278 |     int QuiltSize[2];
279 |     int QuiltTiles[2];
280 |     double AspectRatio;
281 |     std::string Name;
282 |   };
283 | 
284 |   vtkLookingGlassInterface();
285 |   ~vtkLookingGlassInterface() override;
286 | 
287 |   bool GetLookingGlassInfo();
288 | 
289 |   VTK_DEPRECATED_IN_9_2_0("Quality is now based on device type.")
290 |   void SetupQuiltSettings(int i);
291 | 
292 |   /**
293 |    * Setup quilt settings based on device type.
294 |    */
295 |   void SetupQuiltSettings(const std::string& deviceType);
296 | 
297 |   /**
298 |    * Setup quilt settings based on device type.
299 |    */
300 |   void SetupQuiltSettings(const DeviceSettings& deviceSettings);
301 | 
302 |   /**
303 |    * Get the device setting by device type.
304 |    */
305 |   static std::map<std::string, DeviceSettings> GetSettingsByDevice();
306 | 
307 |   /**
308 |    * Get the device setting for a give device.
309 |    */
310 |   static DeviceSettings GetSettingsForDevice(const std::string deviceType);
311 | 
312 |   /**
313 |    * Graphics resources.
314 |    */
315 |   vtkOpenGLFramebufferObject* RenderFramebuffer;
316 |   vtkOpenGLFramebufferObject* QuiltFramebuffer;
317 |   vtkTextureObject* QuiltTexture;
318 |   vtkOpenGLQuadHelper* FinalBlend;
319 |   vtkOpenGLQuadHelper* QuiltBlend;
320 | 
321 |   // with multiple LookingGlass which one to use. Defaults to the first.
322 |   int DeviceIndex;
323 | 
324 |   // the device type, used to setup quilt settings, default to large
325 |   std::string DeviceType;
326 | 
327 |   bool UseClippingLimits;
328 |   double FarClippingLimit;
329 |   double NearClippingLimit;
330 | 
331 |   // see the respective Get methods for descriptions
332 |   int DisplayPosition[2];
333 |   int DisplaySize[2];
334 |   double ViewAngle;
335 |   int QuiltSize[2];
336 |   int QuiltTiles[2];
337 |   int RenderSize[2];
338 |   int NumberOfTiles;
339 | 
340 |   int QuiltQuality;
341 | 
342 |   // has the interface been initialized
343 |   bool Initialized;
344 | 
345 |   // are we connected to a looking glass device
346 |   bool Connected;
347 | 
348 |   // Are we recording a movie
349 |   bool IsRecording;
350 | 
351 |   // The aspect ratio to use when adjusting the camera to render the tiles.
352 |   // This is modifiable so that we can generate quilts for devices that have
353 |   // a different aspect ratio than the device currently connected.
354 |   double AdjustCameraAspectRatio;
355 | 
356 |   // For recording a movie
357 |   vtkImageData* MovieImageBuffer;
358 |   vtkImageData* MovieImageData;
359 |   vtkGenericMovieWriter* MovieWriter;
360 | 
361 |   void DrawLightFieldInternal(vtkOpenGLRenderWindow* renWin, vtkTextureObject* tex);
362 | 
363 | private:
364 |   vtkLookingGlassInterface(const vtkLookingGlassInterface&) = delete;
365 |   void operator=(const vtkLookingGlassInterface&) = delete;
366 | };
367 | 
368 | #endif
369 | 


--------------------------------------------------------------------------------
/vtkLookingGlassPass.cxx:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | 
 13 | #include "vtkLookingGlassPass.h"
 14 | #include "vtkObjectFactory.h"
 15 | #include <cassert>
 16 | 
 17 | #include "vtkLookingGlassInterface.h"
 18 | #include "vtkOpenGLError.h"
 19 | #include "vtkOpenGLFramebufferObject.h"
 20 | #include "vtkOpenGLRenderWindow.h"
 21 | #include "vtkRenderState.h"
 22 | #include "vtkRenderer.h"
 23 | #include "vtkRendererCollection.h"
 24 | 
 25 | vtkStandardNewMacro(vtkLookingGlassPass);
 26 | 
 27 | vtkCxxSetObjectMacro(vtkLookingGlassPass, DelegatePass, vtkRenderPass);
 28 | 
 29 | //------------------------------------------------------------------------------
 30 | vtkLookingGlassPass::vtkLookingGlassPass()
 31 |   : DelegatePass(nullptr)
 32 | {
 33 |   this->Interface = vtkLookingGlassInterface::New();
 34 |   this->Interface->Initialize();
 35 | }
 36 | 
 37 | //------------------------------------------------------------------------------
 38 | vtkLookingGlassPass::~vtkLookingGlassPass()
 39 | {
 40 |   this->Interface->Delete();
 41 |   if (this->DelegatePass != nullptr)
 42 |   {
 43 |     this->DelegatePass->Delete();
 44 |   }
 45 | }
 46 | 
 47 | void vtkLookingGlassPass::ReleaseGraphicsResources(vtkWindow* w)
 48 | {
 49 |   assert("pre: w_exists" && w != nullptr);
 50 | 
 51 |   this->Interface->ReleaseGraphicsResources(w);
 52 |   this->Superclass::ReleaseGraphicsResources(w);
 53 | }
 54 | 
 55 | //------------------------------------------------------------------------------
 56 | void vtkLookingGlassPass::PrintSelf(ostream& os, vtkIndent indent)
 57 | {
 58 |   this->Superclass::PrintSelf(os, indent);
 59 | }
 60 | 
 61 | //------------------------------------------------------------------------------
 62 | // Description:
 63 | // Perform rendering according to a render state \p s.
 64 | // \pre s_exists: s!=0
 65 | void vtkLookingGlassPass::Render(const vtkRenderState* s)
 66 | {
 67 |   assert("pre: s_exists" && s != nullptr);
 68 | 
 69 |   vtkOpenGLClearErrorMacro();
 70 | 
 71 |   this->NumberOfRenderedProps = 0;
 72 | 
 73 |   vtkRenderer* r = s->GetRenderer();
 74 |   vtkRenderState s2(r);
 75 |   s2.SetPropArrayAndCount(s->GetPropArray(), s->GetPropArrayCount());
 76 | 
 77 |   vtkOpenGLRenderWindow* renWin = static_cast<vtkOpenGLRenderWindow*>(r->GetRenderWindow());
 78 | 
 79 |   if (this->DelegatePass == nullptr)
 80 |   {
 81 |     vtkWarningMacro(<< " no delegate.");
 82 |     return;
 83 |   }
 84 | 
 85 |   this->Interface->Initialize();
 86 |   vtkOpenGLFramebufferObject* renderFramebuffer;
 87 |   vtkOpenGLFramebufferObject* quiltFramebuffer;
 88 |   this->Interface->GetFramebuffers(renWin, renderFramebuffer, quiltFramebuffer);
 89 | 
 90 |   s2.SetFrameBuffer(renderFramebuffer);
 91 |   std::function<void(void)> renderFunc = [this, &s2]() { this->DelegatePass->Render(&s2); };
 92 | 
 93 |   // Only render with this single renderer
 94 |   vtkNew<vtkRendererCollection> renderers;
 95 |   renderers->AddItem(r);
 96 | 
 97 |   this->Interface->RenderQuilt(renWin, renderers, &renderFunc);
 98 |   this->Interface->DrawLightField(renWin);
 99 | 
100 |   vtkOpenGLCheckErrorMacro("failed after Render");
101 | }
102 | 


--------------------------------------------------------------------------------
/vtkLookingGlassPass.h:
--------------------------------------------------------------------------------
 1 | /*=========================================================================
 2 | 
 3 |   Copyright (c) 2020 Kitware, Inc.
 4 |   All rights reserved.
 5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 6 | 
 7 |      This software is distributed WITHOUT ANY WARRANTY; without even
 8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 9 |      PURPOSE.  See the above copyright notice for more information.
10 | 
11 | =========================================================================*/
12 | /**
13 |  * @class   vtkLookingGlassPass
14 |  * @brief   Render qulited image for LookingGlass
15 |  *
16 |  * @sa
17 |  * vtkRenderPass
18 |  */
19 | 
20 | #ifndef vtkLookingGlassPass_h
21 | #define vtkLookingGlassPass_h
22 | 
23 | #include "vtkRenderingLookingGlassModule.h" // For export macro
24 | #include "vtkOpenGLRenderPass.h"
25 | 
26 | class vtkLookingGlassInterface;
27 | class vtkOpenGLFramebufferObject;
28 | class vtkOpenGLHelper;
29 | class vtkOpenGLRenderWindow;
30 | class vtkTextureObject;
31 | 
32 | class VTKRENDERINGLOOKINGGLASS_EXPORT vtkLookingGlassPass : public vtkOpenGLRenderPass
33 | {
34 | public:
35 |   static vtkLookingGlassPass* New();
36 |   vtkTypeMacro(vtkLookingGlassPass, vtkOpenGLRenderPass);
37 |   void PrintSelf(ostream& os, vtkIndent indent) override;
38 | 
39 |   /**
40 |    * Perform rendering according to a render state \p s.
41 |    * \pre s_exists: s!=0
42 |    */
43 |   void Render(const vtkRenderState* s) override;
44 | 
45 |   /**
46 |    * Release graphics resources and ask components to release their own
47 |    * resources.
48 |    * \pre w_exists: w!=0
49 |    */
50 |   void ReleaseGraphicsResources(vtkWindow* w) override;
51 | 
52 |   //@{
53 |   /**
54 |    * Delegate for rendering the image to be processed.
55 |    * If it is NULL, nothing will be rendered and a warning will be emitted.
56 |    * It is usually set to a vtkCameraPass or to a post-processing pass.
57 |    * Initial value is a NULL pointer.
58 |    */
59 |   vtkGetObjectMacro(DelegatePass, vtkRenderPass);
60 |   virtual void SetDelegatePass(vtkRenderPass* delegatePass);
61 |   //@}
62 | 
63 |   // Get the LookingGlassInterface being used by this pass.
64 |   // This is useful to set the position and size of the
65 |   // render window.
66 |   vtkGetObjectMacro(Interface, vtkLookingGlassInterface);
67 | 
68 | protected:
69 |   /**
70 |    * Default constructor. DelegatePass is set to NULL.
71 |    */
72 |   vtkLookingGlassPass();
73 | 
74 |   /**
75 |    * Destructor.
76 |    */
77 |   ~vtkLookingGlassPass() override;
78 | 
79 |   vtkRenderPass* DelegatePass;
80 | 
81 |   vtkLookingGlassInterface* Interface;
82 | 
83 | private:
84 |   vtkLookingGlassPass(const vtkLookingGlassPass&) = delete;
85 |   void operator=(const vtkLookingGlassPass&) = delete;
86 | };
87 | 
88 | #endif
89 | 


--------------------------------------------------------------------------------
/vtkLookingGlassRenderWindowImpl.h:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | /**
 13 |  * This header includes code common to all OS specific RenderWindows
 14 |  */
 15 | 
 16 | #include "vtkLookingGlassInterface.h"
 17 | #include "vtkObjectFactory.h"
 18 | #include "vtkRenderingOpenGLConfigure.h" // for VTK_USE_COCOA
 19 | 
 20 | vtkStandardNewMacro(className);
 21 | 
 22 | //------------------------------------------------------------------------------
 23 | className::className()
 24 | {
 25 |   InitializeInterface();
 26 | }
 27 | 
 28 | //------------------------------------------------------------------------------
 29 | void className::InitializeInterface()
 30 | {
 31 |   if (!this->Interface)
 32 |   {
 33 |     this->Interface = vtkLookingGlassInterface::New();
 34 |   }
 35 | 
 36 |   this->Interface->Initialize();
 37 |   this->Interface->GetDisplaySize(this->Size[0], this->Size[1]);
 38 |   this->Interface->GetDisplayPosition(this->Position[0], this->Position[1]);
 39 |   this->BordersOff();
 40 | #ifdef VTK_USE_COCOA
 41 |   this->FullScreenOn();
 42 | #endif
 43 | }
 44 | 
 45 | //------------------------------------------------------------------------------
 46 | className::~className()
 47 | {
 48 |   this->Finalize();
 49 |   this->Interface->Delete();
 50 | }
 51 | 
 52 | //------------------------------------------------------------------------------
 53 | void className::ReleaseGraphicsResources(vtkWindow* renWin)
 54 | {
 55 |   this->Interface->ReleaseGraphicsResources(renWin);
 56 |   this->Superclass::ReleaseGraphicsResources(renWin);
 57 | }
 58 | 
 59 | //------------------------------------------------------------------------------
 60 | // We override this method to render the tiles required by the looking glass
 61 | // display then render the resulting lightfield to the window
 62 | void className::DoStereoRender()
 63 | {
 64 |   this->StereoUpdate();
 65 | 
 66 |   int renderSize[2];
 67 |   this->Interface->GetRenderSize(renderSize);
 68 | 
 69 |   int origSize[2] = { this->Size[0], this->Size[1] };
 70 |   this->InStereoRender = true;
 71 |   this->Size[0] = renderSize[0];
 72 |   this->Size[1] = renderSize[1];
 73 | 
 74 |   this->Interface->RenderQuilt(this);
 75 | 
 76 |   this->InStereoRender = false;
 77 |   this->Size[0] = origSize[0];
 78 |   this->Size[1] = origSize[1];
 79 | 
 80 |   this->Interface->DrawLightField(this);
 81 | }
 82 | 
 83 | //------------------------------------------------------------------------------
 84 | // Get the current size of the window (or when rendering tiles the tile size)
 85 | int* className::GetSize(void)
 86 | {
 87 |   // when rendering to a tile we have a different size already set
 88 |   // just return the ivar unchanged
 89 |   if (this->InStereoRender)
 90 |   {
 91 |     return this->Size;
 92 |   }
 93 | 
 94 |   return this->Superclass::GetSize();
 95 | }
 96 | 
 97 | //------------------------------------------------------------------------------
 98 | void className::SetLGDeviceIndex(int index)
 99 | {
100 |   this->Interface->SetDeviceIndex(index);
101 | }
102 | 
103 | //------------------------------------------------------------------------------
104 | void className::SaveQuilt(const char* fileName)
105 | {
106 |   this->Interface->SaveQuilt(fileName);
107 | }
108 | 
109 | //------------------------------------------------------------------------------
110 | void className::StartRecordingQuilt(const char* fileName)
111 | {
112 |   this->Interface->StartRecordingQuilt(fileName);
113 | }
114 | 
115 | //------------------------------------------------------------------------------
116 | void className::StopRecordingQuilt()
117 | {
118 |   this->Interface->StopRecordingQuilt();
119 | }
120 | 
121 | //------------------------------------------------------------------------------
122 | const char* className::MovieFileExtension()
123 | {
124 |   return vtkLookingGlassInterface::MovieFileExtension();
125 | }
126 | 
127 | //------------------------------------------------------------------------------
128 | std::string className::QuiltFileSuffix() const
129 | {
130 |   return this->Interface->QuiltFileSuffix();
131 | }
132 | 
133 | //------------------------------------------------------------------------------
134 | void className::SetUseClippingLimits(bool b)
135 | {
136 |   this->Interface->SetUseClippingLimits(b);
137 | }
138 | 
139 | //------------------------------------------------------------------------------
140 | bool className::GetUseClippingLimits() const
141 | {
142 |   return this->Interface->GetUseClippingLimits();
143 | }
144 | 
145 | //------------------------------------------------------------------------------
146 | void className::SetFarClippingLimit(double d)
147 | {
148 |   this->Interface->SetFarClippingLimit(d);
149 | }
150 | 
151 | //------------------------------------------------------------------------------
152 | double className::GetFarClippingLimit() const
153 | {
154 |   return this->Interface->GetFarClippingLimit();
155 | }
156 | 
157 | //------------------------------------------------------------------------------
158 | void className::SetNearClippingLimit(double d)
159 | {
160 |   this->Interface->SetNearClippingLimit(d);
161 | }
162 | 
163 | //------------------------------------------------------------------------------
164 | double className::GetNearClippingLimit() const
165 | {
166 |   return this->Interface->GetNearClippingLimit();
167 | }
168 | 
169 | //------------------------------------------------------------------------------
170 | bool className::IsRecordingQuilt() const
171 | {
172 |   return this->Interface->IsRecordingQuilt();
173 | }
174 | 
175 | //------------------------------------------------------------------------------
176 | void className::SetDeviceIndex(int i)
177 | {
178 |   this->Interface->SetDeviceIndex(i);
179 | }
180 | 
181 | //------------------------------------------------------------------------------
182 | int className::GetDeviceIndex() const
183 | {
184 |   return this->Interface->GetDeviceIndex();
185 | }
186 | 
187 | //------------------------------------------------------------------------------
188 | void className::SetDeviceType(const std::string& t)
189 | {
190 |   // Must re-build the interface from scratch
191 |   if (this->Interface)
192 |   {
193 |     this->Interface->ReleaseGraphicsResources(this);
194 |     this->Interface->Delete();
195 |     this->Interface = nullptr;
196 |   }
197 | 
198 |   this->Interface = vtkLookingGlassInterface::New();
199 |   this->Interface->SetDeviceType(t);
200 |   InitializeInterface();
201 | }
202 | 
203 | //------------------------------------------------------------------------------
204 | std::string className::GetDeviceType() const
205 | {
206 |   return this->Interface->GetDeviceType();
207 | }
208 | 
209 | //------------------------------------------------------------------------------
210 | std::vector<std::string> className::GetDeviceTypes()
211 | {
212 |   std::vector<std::string> types;
213 |   for (const auto device : vtkLookingGlassInterface::GetDevices())
214 |   {
215 |     types.push_back(device.first);
216 |   }
217 | 
218 |   return types;
219 | }
220 | 


--------------------------------------------------------------------------------
/vtkWin32LookingGlassRenderWindow.cxx:
--------------------------------------------------------------------------------
 1 | /*=========================================================================
 2 | 
 3 |   Copyright (c) 2020 Kitware, Inc.
 4 |   All rights reserved.
 5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 6 | 
 7 |      This software is distributed WITHOUT ANY WARRANTY; without even
 8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 9 |      PURPOSE.  See the above copyright notice for more information.
10 | 
11 | =========================================================================*/
12 | #include "vtkWin32LookingGlassRenderWindow.h"
13 | 
14 | #define className vtkWin32LookingGlassRenderWindow
15 | #include "vtkLookingGlassRenderWindowImpl.h"
16 | 


--------------------------------------------------------------------------------
/vtkWin32LookingGlassRenderWindow.h:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | /**
 13 |  * @class   vtkWin32LookingGlassRenderWindow
 14 |  * @brief   LookingGlass rendering window
 15 |  *
 16 |  * A drop in replacement on Windows for vtkOpenGLRenderWindow that will
 17 |  * render to a LookingGlass display
 18 |  */
 19 | 
 20 | #ifndef vtkWin32LookingGlassRenderWindow_h
 21 | #define vtkWin32LookingGlassRenderWindow_h
 22 | 
 23 | #include "vtkRenderingLookingGlassModule.h" // For export macro
 24 | #include "vtkWin32OpenGLRenderWindow.h"
 25 | 
 26 | class vtkLookingGlassInterface;
 27 | 
 28 | class VTKRENDERINGLOOKINGGLASS_EXPORT vtkWin32LookingGlassRenderWindow : public vtkWin32OpenGLRenderWindow
 29 | {
 30 | public:
 31 |   static vtkWin32LookingGlassRenderWindow* New();
 32 |   vtkTypeMacro(vtkWin32LookingGlassRenderWindow, vtkWin32OpenGLRenderWindow);
 33 | 
 34 |   // Get the LookingGlassInterface being used by this window.
 35 |   vtkGetObjectMacro(Interface, vtkLookingGlassInterface);
 36 | 
 37 |   /**
 38 |    * Get the size (width and height) of the rendering window.
 39 |    * We override so that durnig the render process we can return
 40 |    * a size of the render framebuffer as opposed to the final
 41 |    * buffer.
 42 |    */
 43 |   int* GetSize() VTK_SIZEHINT(2) override;
 44 | 
 45 |   /**
 46 |    * Free up any graphics resources associated with this window
 47 |    * a value of nullptr means the context may already be destroyed
 48 |    */
 49 |   void ReleaseGraphicsResources(vtkWindow*) override;
 50 | 
 51 |   /**
 52 |    * Set index of the Looking Glass device on which this window should appear.
 53 |    */
 54 |   void SetLGDeviceIndex(int index);
 55 | 
 56 |   /**
 57 |    * Save a quilt to a PNG file
 58 |    */
 59 |   void SaveQuilt(const char* fileName);
 60 | 
 61 |   /**
 62 |    * Start recording a quilt
 63 |    */
 64 |   void StartRecordingQuilt(const char* fileName);
 65 | 
 66 |   /**
 67 |    * Stop recording a quilt
 68 |    */
 69 |   void StopRecordingQuilt();
 70 | 
 71 |   /**
 72 |    * Get the movie extension that should be used for quilt movies
 73 |    */
 74 |   static const char* MovieFileExtension();
 75 | 
 76 |   /**
 77 |    * Get the quilt file suffix as a string. The suffix encodes the number of
 78 |    * tiles in the width and the height. For example, if the quilt file name
 79 |    * is "quilt_qs5x9.png", the suffix is "_qs5x9", and it means that the quilt
 80 |    * is 5 tiles wide and 9 tiles high.
 81 |    */
 82 |   std::string QuiltFileSuffix() const;
 83 | 
 84 |   /**
 85 |    * Turn on/off use of near and far clipping limits.
 86 |    */
 87 |   void SetUseClippingLimits(bool b);
 88 | 
 89 |   /**
 90 |    * Turn on/off use of near and far clipping limits.
 91 |    */
 92 |   bool GetUseClippingLimits() const;
 93 |   vtkBooleanMacro(UseClippingLimits, bool);
 94 | 
 95 |   /**
 96 |    * Set/Get limit for the ratio of the far clipping plane to the focal
 97 |    * distance. This is a mechanism to limit parallex and resulting
 98 |    * ghosting when using the looking glass display. The typical value
 99 |    * should be around 1.2.
100 |    */
101 |   void SetFarClippingLimit(double d);
102 | 
103 |   /**
104 |    * Set/Get limit for the ratio of the far clipping plane to the focal
105 |    * distance. This is a mechanism to limit parallex and resulting
106 |    * ghosting when using the looking glass display. The typical value
107 |    * should be around 1.2.
108 |    */
109 |   double GetFarClippingLimit() const;
110 | 
111 |   /**
112 |    * Set/Get limit for the ratio of the near clipping plane to the focal
113 |    * distance. This is a mechanism to limit parallex and resulting
114 |    * ghosting when using the looking glass display. The typical value
115 |    * should be around 0.8.
116 |    */
117 |   void SetNearClippingLimit(double d);
118 | 
119 |   /**
120 |    * Set/Get limit for the ratio of the near clipping plane to the focal
121 |    * distance. This is a mechanism to limit parallex and resulting
122 |    * ghosting when using the looking glass display. The typical value
123 |    * should be around 0.8.
124 |    */
125 |   double GetNearClippingLimit() const;
126 | 
127 |   /**
128 |    * Check if a movie quilt is currently being recorded.
129 |    */
130 |   bool IsRecordingQuilt() const;
131 | 
132 |   /**
133 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
134 |    * increases.
135 |    */
136 |   void SetDeviceIndex(int i);
137 | 
138 |   /**
139 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
140 |    * increases.
141 |    */
142 |   int GetDeviceIndex() const;
143 | 
144 |   /**
145 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
146 |    * generated for a device that is not connected in the future.
147 |    */
148 |   void SetDeviceType(const std::string &t);
149 | 
150 |   /**
151 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
152 |    * generated for a device that is not connected in the future.
153 |    */
154 |   std::string GetDeviceType() const;
155 | 
156 |   /**
157 |    * Returns a vector of available device types.
158 |    */
159 |   static std::vector<std::string> GetDeviceTypes();
160 | 
161 | protected:
162 |   vtkWin32LookingGlassRenderWindow();
163 |   ~vtkWin32LookingGlassRenderWindow() override;
164 | 
165 |   vtkLookingGlassInterface* Interface = nullptr;
166 | 
167 |   void InitializeInterface();
168 | 
169 |   void DoStereoRender() override;
170 |   bool InStereoRender;
171 | 
172 | private:
173 |   vtkWin32LookingGlassRenderWindow(const vtkWin32LookingGlassRenderWindow&) = delete;
174 |   void operator=(const vtkWin32LookingGlassRenderWindow&) = delete;
175 | };
176 | 
177 | #endif
178 | 


--------------------------------------------------------------------------------
/vtkXLookingGlassRenderWindow.cxx:
--------------------------------------------------------------------------------
 1 | /*=========================================================================
 2 | 
 3 |   Copyright (c) 2020 Kitware, Inc.
 4 |   All rights reserved.
 5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 6 | 
 7 |      This software is distributed WITHOUT ANY WARRANTY; without even
 8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 9 |      PURPOSE.  See the above copyright notice for more information.
10 | 
11 | =========================================================================*/
12 | #include "vtkXLookingGlassRenderWindow.h"
13 | 
14 | #define className vtkXLookingGlassRenderWindow
15 | #include "vtkLookingGlassRenderWindowImpl.h"
16 | 


--------------------------------------------------------------------------------
/vtkXLookingGlassRenderWindow.h:
--------------------------------------------------------------------------------
  1 | /*=========================================================================
  2 | 
  3 |   Copyright (c) 2020 Kitware, Inc.
  4 |   All rights reserved.
  5 |   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  6 | 
  7 |      This software is distributed WITHOUT ANY WARRANTY; without even
  8 |      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  9 |      PURPOSE.  See the above copyright notice for more information.
 10 | 
 11 | =========================================================================*/
 12 | /**
 13 |  * @class   vtkXLookingGlassRenderWindow
 14 |  * @brief   LookingGlass rendering window
 15 |  *
 16 |  * A drop in replacement on Windows for vtkOpenGLRenderWindow that will
 17 |  * render to a LookingGlass display
 18 |  */
 19 | 
 20 | #ifndef vtkXLookingGlassRenderWindow_h
 21 | #define vtkXLookingGlassRenderWindow_h
 22 | 
 23 | #include "vtkRenderingLookingGlassModule.h" // For export macro
 24 | #include "vtkXOpenGLRenderWindow.h"
 25 | 
 26 | class vtkLookingGlassInterface;
 27 | 
 28 | class VTKRENDERINGLOOKINGGLASS_EXPORT vtkXLookingGlassRenderWindow : public vtkXOpenGLRenderWindow
 29 | {
 30 | public:
 31 |   static vtkXLookingGlassRenderWindow* New();
 32 |   vtkTypeMacro(vtkXLookingGlassRenderWindow, vtkXOpenGLRenderWindow);
 33 | 
 34 |   // Get the LookingGlassInterface being used by this window.
 35 |   vtkGetObjectMacro(Interface, vtkLookingGlassInterface);
 36 | 
 37 |   /**
 38 |    * Get the size (width and height) of the rendering window.
 39 |    * We override so that durnig the render process we can return
 40 |    * a size of the render framebuffer as opposed to the final
 41 |    * buffer.
 42 |    */
 43 |   int* GetSize() VTK_SIZEHINT(2) override;
 44 | 
 45 |   /**
 46 |    * Free up any graphics resources associated with this window
 47 |    * a value of nullptr means the context may already be destroyed
 48 |    */
 49 |   void ReleaseGraphicsResources(vtkWindow*) override;
 50 | 
 51 |   /**
 52 |    * Set index of the Looking Glass device on which this window should appear.
 53 |    */
 54 |   void SetLGDeviceIndex(int index);
 55 | 
 56 |   /**
 57 |    * Save a quilt to a PNG file
 58 |    */
 59 |   void SaveQuilt(const char* fileName);
 60 | 
 61 |   /**
 62 |    * Start recording a quilt
 63 |    */
 64 |   void StartRecordingQuilt(const char* fileName);
 65 | 
 66 |   /**
 67 |    * Stop recording a quilt
 68 |    */
 69 |   void StopRecordingQuilt();
 70 | 
 71 |   /**
 72 |    * Get the movie extension that should be used for quilt movies
 73 |    */
 74 |   static const char* MovieFileExtension();
 75 | 
 76 |   /**
 77 |    * Get the quilt file suffix as a string. The suffix encodes the number of
 78 |    * tiles in the width and the height. For example, if the quilt file name
 79 |    * is "quilt_qs5x9.png", the suffix is "_qs5x9", and it means that the quilt
 80 |    * is 5 tiles wide and 9 tiles high.
 81 |    */
 82 |   std::string QuiltFileSuffix() const;
 83 | 
 84 |   /**
 85 |    * Turn on/off use of near and far clipping limits.
 86 |    */
 87 |   void SetUseClippingLimits(bool b);
 88 | 
 89 |   /**
 90 |    * Turn on/off use of near and far clipping limits.
 91 |    */
 92 |   bool GetUseClippingLimits() const;
 93 |   vtkBooleanMacro(UseClippingLimits, bool);
 94 | 
 95 |   /**
 96 |    * Set/Get limit for the ratio of the far clipping plane to the focal
 97 |    * distance. This is a mechanism to limit parallex and resulting
 98 |    * ghosting when using the looking glass display. The typical value
 99 |    * should be around 1.2.
100 |    */
101 |   void SetFarClippingLimit(double d);
102 | 
103 |   /**
104 |    * Set/Get limit for the ratio of the far clipping plane to the focal
105 |    * distance. This is a mechanism to limit parallex and resulting
106 |    * ghosting when using the looking glass display. The typical value
107 |    * should be around 1.2.
108 |    */
109 |   double GetFarClippingLimit() const;
110 | 
111 |   /**
112 |    * Set/Get limit for the ratio of the near clipping plane to the focal
113 |    * distance. This is a mechanism to limit parallex and resulting
114 |    * ghosting when using the looking glass display. The typical value
115 |    * should be around 0.8.
116 |    */
117 |   void SetNearClippingLimit(double d);
118 | 
119 |   /**
120 |    * Set/Get limit for the ratio of the near clipping plane to the focal
121 |    * distance. This is a mechanism to limit parallex and resulting
122 |    * ghosting when using the looking glass display. The typical value
123 |    * should be around 0.8.
124 |    */
125 |   double GetNearClippingLimit() const;
126 | 
127 |   /**
128 |    * Check if a movie quilt is currently being recorded.
129 |    */
130 |   bool IsRecordingQuilt() const;
131 | 
132 |   /**
133 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
134 |    * increases.
135 |    */
136 |   void SetDeviceIndex(int i);
137 | 
138 |   /**
139 |    * Set/Get which LookingGlass device to use. DeviceIndex starts at 0 and
140 |    * increases.
141 |    */
142 |   int GetDeviceIndex() const;
143 | 
144 |   /**
145 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
146 |    * generated for a device that is not connected in the future.
147 |    */
148 |   void SetDeviceType(const std::string &t);
149 | 
150 |   /**
151 |    * Set/Get which LookingGlass device type to target. This allows a quilt to be
152 |    * generated for a device that is not connected in the future.
153 |    */
154 |   std::string GetDeviceType() const;
155 | 
156 |   /**
157 |    * Returns a vector of available device types.
158 |    */
159 |   static std::vector<std::string> GetDeviceTypes();
160 | 
161 | protected:
162 |   vtkXLookingGlassRenderWindow();
163 |   ~vtkXLookingGlassRenderWindow() override;
164 | 
165 |   vtkLookingGlassInterface* Interface = nullptr;
166 | 
167 |   void InitializeInterface();
168 | 
169 |   void DoStereoRender() override;
170 |   bool InStereoRender;
171 | 
172 | private:
173 |   vtkXLookingGlassRenderWindow(const vtkXLookingGlassRenderWindow&) = delete;
174 |   void operator=(const vtkXLookingGlassRenderWindow&) = delete;
175 | };
176 | 
177 | #endif
178 | 


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