[1.3.66] 2026-03-05

## Core
- Added `writeEXR()` functions for writing single-channel and multi-channel float images to OpenEXR files with lossless ZIP compression, using the tinyexr header-only library.

## Radiation
- Added `writeCameraImageDataEXR()` and `writeDepthImageDataEXR()` methods for exporting camera and depth data to EXR files, preserving full floating-point precision.

## Visualizer
- Fixed bug in colorbar ticks where ticks could extend past the colorbar.

## Radiation
- Added OptiX 8.1 ray tracing backend for NVIDIA systems with driver ≥ 560. This resolves the driver 590+ incompatibility that prevented the OptiX 6.5 backend from working on modern NVIDIA drivers. The backend is selected automatically at build time: driver ≥ 560 uses OptiX 8.1; driver < 560 continues to use OptiX 6.5.

Author: bnbailey-psl

core/CMakeLists.txt

@@ -45,6 +45,8 @@ add_dependencies( png_static zlibstatic )
 include_directories("${CMAKE_BINARY_DIR}/lib/libjpeg-9a" "${CMAKE_CURRENT_SOURCE_DIR}/lib/libjpeg-9a")
 add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/lib/libjpeg-9a" "${CMAKE_BINARY_DIR}/lib/libjpeg-9a")
 
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/lib/tinyexr")
+
 target_link_libraries( helios PRIVATE png_static  jpeg ) #note that zlib is already linked by libpng
 
 # Suppress warnings for third-party libraries

core/include/global.h

@@ -878,6 +878,26 @@ namespace helios {
      */
     void writeJPEG(const std::string &filename, uint width, uint height, const std::vector<unsigned char> &pixel_data);
 
+    //! Write a single-channel float image to an EXR file with lossless ZIP compression
+    /**
+     * \param[in] filename Name of the EXR image file
+     * \param[in] width Image width in pixels
+     * \param[in] height Image height in pixels
+     * \param[in] pixel_data Float values at each pixel (index at pixel_data[row*width+column])
+     * \param[in] channel_name Name of the EXR channel (default "Y" for grayscale; use "Z" for depth)
+     */
+    void writeEXR(const std::string &filename, uint width, uint height, const std::vector<float> &pixel_data, const std::string &channel_name = "Y");
+
+    //! Write a multi-channel float image to an EXR file with lossless ZIP compression
+    /**
+     * \param[in] filename Name of the EXR image file
+     * \param[in] width Image width in pixels
+     * \param[in] height Image height in pixels
+     * \param[in] channel_data Vector of per-channel float data, each of length width*height
+     * \param[in] channel_names Names for each channel (e.g., {"R", "G", "B"}). Channels are sorted alphabetically per EXR convention.
+     */
+    void writeEXR(const std::string &filename, uint width, uint height, const std::vector<std::vector<float>> &channel_data, const std::vector<std::string> &channel_names);
+
     //! Template function to flatten a 2D vector into a 1D vector
     /**
      * \ingroup functions

core/src/global.cpp

@@ -27,6 +27,12 @@ extern "C" {
 #include "jpeglib.h"
 }
 
+// EXR Libraries (reading and writing OpenEXR images)
+#define TINYEXR_USE_MINIZ 0
+#include "zlib.h"
+#define TINYEXR_IMPLEMENTATION
+#include "tinyexr.h"
+
 using namespace helios;
 
 void helios::helios_runtime_error(const std::string &error_message) {
@@ -2060,6 +2066,128 @@ void helios::writeJPEG(const std::string &a_filename, uint width, uint height, c
     writeJPEG(a_filename, width, height, rgb_data);
 }
 
+void helios::writeEXR(const std::string &filename, uint width, uint height, const std::vector<float> &pixel_data, const std::string &channel_name) {
+
+    if (pixel_data.size() != width * height) {
+        helios_runtime_error("ERROR (writeEXR): pixel_data size (" + std::to_string(pixel_data.size()) + ") does not match width*height (" + std::to_string(width * height) + ").");
+    }
+
+    EXRHeader header;
+    InitEXRHeader(&header);
+
+    EXRImage image;
+    InitEXRImage(&image);
+
+    image.num_channels = 1;
+    image.width = scast<int>(width);
+    image.height = scast<int>(height);
+
+    float *image_ptr[1];
+    image_ptr[0] = const_cast<float *>(pixel_data.data());
+
+    image.images = reinterpret_cast<unsigned char **>(image_ptr);
+
+    header.num_channels = 1;
+    header.channels = scast<EXRChannelInfo *>(malloc(sizeof(EXRChannelInfo)));
+    strncpy(header.channels[0].name, channel_name.c_str(), 255);
+    header.channels[0].name[255] = '\0';
+
+    header.pixel_types = scast<int *>(malloc(sizeof(int)));
+    header.requested_pixel_types = scast<int *>(malloc(sizeof(int)));
+    header.pixel_types[0] = TINYEXR_PIXELTYPE_FLOAT;
+    header.requested_pixel_types[0] = TINYEXR_PIXELTYPE_FLOAT;
+
+    header.compression_type = TINYEXR_COMPRESSIONTYPE_ZIP;
+
+    const char *err = nullptr;
+    int ret = SaveEXRImageToFile(&image, &header, filename.c_str(), &err);
+
+    free(header.channels);
+    free(header.pixel_types);
+    free(header.requested_pixel_types);
+
+    if (ret != TINYEXR_SUCCESS) {
+        std::string error_msg = "ERROR (writeEXR): Failed to write EXR file '" + filename + "'";
+        if (err) {
+            error_msg += ": " + std::string(err);
+            FreeEXRErrorMessage(err);
+        }
+        helios_runtime_error(error_msg);
+    }
+}
+
+void helios::writeEXR(const std::string &filename, uint width, uint height, const std::vector<std::vector<float>> &channel_data, const std::vector<std::string> &channel_names) {
+
+    if (channel_data.size() != channel_names.size()) {
+        helios_runtime_error("ERROR (writeEXR): channel_data size (" + std::to_string(channel_data.size()) + ") does not match channel_names size (" + std::to_string(channel_names.size()) + ").");
+    }
+    if (channel_data.empty()) {
+        helios_runtime_error("ERROR (writeEXR): channel_data is empty.");
+    }
+    for (size_t c = 0; c < channel_data.size(); c++) {
+        if (channel_data[c].size() != width * height) {
+            helios_runtime_error("ERROR (writeEXR): channel_data[" + std::to_string(c) + "] size (" + std::to_string(channel_data[c].size()) + ") does not match width*height (" + std::to_string(width * height) + ").");
+        }
+    }
+
+    int num_channels = scast<int>(channel_data.size());
+
+    // Sort channels alphabetically (EXR convention)
+    std::vector<size_t> sort_indices(num_channels);
+    for (size_t i = 0; i < sort_indices.size(); i++) {
+        sort_indices[i] = i;
+    }
+    std::sort(sort_indices.begin(), sort_indices.end(), [&](size_t a, size_t b) {
+        return channel_names[a] < channel_names[b];
+    });
+
+    EXRHeader header;
+    InitEXRHeader(&header);
+
+    EXRImage image;
+    InitEXRImage(&image);
+
+    image.num_channels = num_channels;
+    image.width = scast<int>(width);
+    image.height = scast<int>(height);
+
+    std::vector<float *> image_ptrs(num_channels);
+    for (int c = 0; c < num_channels; c++) {
+        image_ptrs[c] = const_cast<float *>(channel_data[sort_indices[c]].data());
+    }
+    image.images = reinterpret_cast<unsigned char **>(image_ptrs.data());
+
+    header.num_channels = num_channels;
+    header.channels = scast<EXRChannelInfo *>(malloc(sizeof(EXRChannelInfo) * num_channels));
+    header.pixel_types = scast<int *>(malloc(sizeof(int) * num_channels));
+    header.requested_pixel_types = scast<int *>(malloc(sizeof(int) * num_channels));
+
+    for (int c = 0; c < num_channels; c++) {
+        strncpy(header.channels[c].name, channel_names[sort_indices[c]].c_str(), 255);
+        header.channels[c].name[255] = '\0';
+        header.pixel_types[c] = TINYEXR_PIXELTYPE_FLOAT;
+        header.requested_pixel_types[c] = TINYEXR_PIXELTYPE_FLOAT;
+    }
+
+    header.compression_type = TINYEXR_COMPRESSIONTYPE_ZIP;
+
+    const char *err = nullptr;
+    int ret = SaveEXRImageToFile(&image, &header, filename.c_str(), &err);
+
+    free(header.channels);
+    free(header.pixel_types);
+    free(header.requested_pixel_types);
+
+    if (ret != TINYEXR_SUCCESS) {
+        std::string error_msg = "ERROR (writeEXR): Failed to write EXR file '" + filename + "'";
+        if (err) {
+            error_msg += ": " + std::string(err);
+            FreeEXRErrorMessage(err);
+        }
+        helios_runtime_error(error_msg);
+    }
+}
+
 helios::vec3 helios::spline_interp3(float u, const vec3 &x_start, const vec3 &tan_start, const vec3 &x_end, const vec3 &tan_end) {
     // Perform interpolation between two 3D points using Cubic Hermite Spline
 

doc/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+# [1.3.66] 2026-03-05
+
+## Core
+- Added `writeEXR()` functions for writing single-channel and multi-channel float images to OpenEXR files with lossless ZIP compression, using the tinyexr header-only library.
+
+## Radiation
+- Added `writeCameraImageDataEXR()` and `writeDepthImageDataEXR()` methods for exporting camera and depth data to EXR files, preserving full floating-point precision.
+
+## Visualizer
+- Fixed bug in colorbar ticks where ticks could extend past the colorbar.
+
+## Radiation
+- Added OptiX 8.1 ray tracing backend for NVIDIA systems with driver ≥ 560. This resolves the driver 590+ incompatibility that prevented the OptiX 6.5 backend from working on modern NVIDIA drivers. The backend is selected automatically at build time: driver ≥ 560 uses OptiX 8.1; driver < 560 continues to use OptiX 6.5.
+
 # [1.3.65] 2026-02-27
 
 ## Core

doc/UserGuide.dox

@@ -251,13 +251,15 @@
   4. Double-click TdrDelay and add 600 for the Value data and make it a Decimal (instead of Hexadecimal). Click OK. If you encounter the same "Display driver stopped responding and has recovered" error in the future, increase the value.
   5. Close the registry editor and restart the computer for the changes to take effect.
 
-  \subsubsection OptiXWSL Manually installing OptiX if using Windows Subsystem for Linux (WSL)
+  \subsubsection OptiXWSL Running OptiX under Windows Subsystem for Linux (WSL)
 
-  OptiX is normally packaged with Helios, such that you do not have to worry about installing it. However, if you are using Windows Subsystem for Linux (WSL), you will need to manually install OptiX since the version included with Helios does not have the required drivers for WSL. You can follow the instructions on this site to perform the installation: <a href="https://forums.developer.nvidia.com/t/problem-running-optix-7-6-in-wsl/239355/7">https://forums.developer.nvidia.com/t/problem-running-optix-7-6-in-wsl/239355/7</a>.
+  Both the OptiX 8.1 and OptiX 6.5 backends are bundled with Helios and do not require a separate OptiX SDK installation. The OptiX runtime is loaded from the NVIDIA driver at runtime via <tt>optixInit()</tt>, so as long as the NVIDIA driver is installed in WSL, no additional steps are needed.
 
-  Alternatively, simply run the dependencies script found in the utilities/ folder: `source dependencies.sh`
+  If you encounter issues finding the NVIDIA driver inside WSL, run the dependencies script in the utilities/ folder:
 
-  This will automatically install and configure the Linux drivers (version 470.256.02) to run OptiX.
+  <tt>source dependencies.sh</tt>
+
+  This will automatically install and configure the Linux driver components needed to run CUDA and OptiX inside WSL.
 
   \subsection SetupPCVulkan Setting up Vulkan for the Radiation Model
 
@@ -2055,13 +2057,21 @@ The table below gives recommendations for Windows and Linux Systems based on you
 
 \section chooseOptiX OptiX Version
 
-The NVIDIA OptiX library is used for ray-tracing calculations associated with the radiation model plug-in. Helios comes packaged with two versions of OptiX: version 5.1 (which we term "legacy") and version 6.5. The newer version (6.5) is what is used by default. If you are using a GPU with compute capability <5.0, you will need to enable the legacy version (see table above).
+The NVIDIA OptiX library is used for ray-tracing calculations in the radiation model. Helios bundles three versions of OptiX and selects among them automatically based on your NVIDIA driver version:
+
+| Driver version | OptiX version used | CUDA requirement |
+|---|---|---|
+| ≥ 560 | OptiX 8.1 (default, recommended) | CUDA 12.0+ |
+| &lt; 560 | OptiX 6.5 (legacy) | CUDA 9.0+ |
+| Any (or no NVIDIA GPU) | Vulkan compute backend | None |
+
+\note NVIDIA drivers 590.x and later dropped support for OptiX 6.5. If you have a modern GPU and driver, Helios automatically uses OptiX 8.1, which supports all current and future NVIDIA drivers. The driver 590+ incompatibility that existed in earlier Helios versions is fully resolved.
 
-There are several ways to tell Helios to build with the legacy OptiX version, all of which involve setting a CMake variable:
+<b>Legacy GPUs (compute capability 3.5):</b> If you are using a GPU with compute capability &lt; 5.0, you can force the OptiX 6.5 legacy backend by setting <tt>-DOPTIX_VERSION_LEGACY=ON</tt>. There are two ways to do this:
 
-1. Pass option to CMake: To always build every project with the legacy OptiX version, it is easiest to set the following CMake option in CLion: "-DOPTIX_VERSION_LEGACY=ON". Go to CLion settings, then "build, execution, deployment -> CMake" Then type "-DOPTIX_VERSION_LEGACY=ON" into the CMake Options box. You can also pass this option to CMake if building from the command line.
+1. Pass option to CMake: Set the following CMake option in CLion: "-DOPTIX_VERSION_LEGACY=ON". Go to CLion settings, then "build, execution, deployment -> CMake", and type "-DOPTIX_VERSION_LEGACY=ON" into the CMake Options box. You can also pass this option to CMake if building from the command line.
 
-2. Add the variable directly in your project CMakeLists.txt file: You can add the line "set( OPTIX_VERSION_LEGACY ON )" to your project CMakeLists.txt file.
+2. Add the variable directly in your project CMakeLists.txt file: Add the line <tt>set( OPTIX_VERSION_LEGACY ON )</tt> to your project CMakeLists.txt file.
 
 
 */