repository·main·Indexed 23 days ago
https://github.com/academysoftwarefoundation/openexrA professional-grade image storage format used in the motion picture industry for high-dynamic-range, multi-part, and multi-channel 2D image data. The project provides a specification and reference implementation, including Python bindings, and supports mandatory Zlib and optional dependencies such as Boost, NumPy, Fltk, and Cg.
OpenJPH is an open-source implementation of High-throughput JPEG2000 (HTJ2K), also referred to as JPH, JPEG2000 Part 15, ISO/IEC 15444-15, and ITU-T T.814.
It focuses specifically on the HTJ2K standard and supports key features defined in JPEG2000 Part 1, including:
OpenEXR is the professional-grade image storage format used in the motion picture industry. It is designed to accurately and efficiently represent high-dynamic-range (HDR) scene-linear image data, supporting multi-part, multi-channel use cases and extensive metadata. It is primarily used in photorealistic rendering, texture access, image compositing, deep compositing, and DI.
The project includes Imath, a lightweight C++ library providing efficient representations of 2D and 3D vectors, matrices, and other mathematical objects common in computer graphics. Imath also includes the half 16-bit floating-point type and provides optional Python bindings for all types and functions, including optimized implementations for vector and matrix arrays.
OpenEXR is licensed under the BSD-3-Clause license.
When redistributing OpenEXR in source or binary forms, you must adhere to the following conditions:
Disclaimer: The software is provided "AS IS" without warranty of any kind. The copyright holders and contributors are not liable for any direct, indirect, incidental, special, exemplary, or consequential damages arising from the use of this software.
OpenEXR is a high dynamic-range (HDR) image file format used in computer imaging applications. It is a standard HDR format for linear and interactive media in computer graphics.
Mandatory Dependency:
Zlib (zlib license)Optional Dependencies:
Boost (Boost license)NumPy (NumPy license)Fltk (FLTK license)Cg (NVIDIA Cg license)OpenEXR is a high-performance image format and library designed for professional visual effects and imaging workflows. Key capabilities include:
The OpenEXR project provides multi-view test images that demonstrate various formatting variations, including different scanline/tiled structures, channel configurations, and compression types. These images are designed for stereo display testing and typically contain at least a left-eye and a right-eye view.
Key variations demonstrated in the test suite include:
scanlineimage or tiledimage (including tiled mip-maps).R, G, B) or single luminance channels (e.g., Y).b44a, piz, and zip compression.OpenEXR is designed for high-quality image processing and storage with the following capabilities:
OpenEXR 3.1 introduced OpenEXRCore, a new library designed to address scalability issues in multithreaded image I/O.
A shallow mask is a pixel-level mask used with non-deep compositing operators. To correctly compute an ID selection mask for a single pixel, you must iterate through the samples sorted front-to-back and accumulate alpha based on the remaining visibility (uncovered alpha).
total_combined_alpha = 0.0
mask_alpha = 0.0
sorted_pixel = sort_pixel_front_to_back(input_pixel)
foreach(sample in sorted_pixel):
if id_is_in_selection(sample.id):
mask_alpha += sample.alpha * (1.0 - total_combined_alpha)
total_combined_alpha += sample.alpha * (1.0 - total_combined_alpha)
if total_combined_alpha == 0.0:
return 0.0
else:
return mask_alpha / total_combined_alphalibdeflate uses compression levels similar to zlib (where level 1 is fastest/lowest compression and level 9 is slowest/highest compression). However, libdeflate extends this range up to level 12.
Levels 10-12 utilize a minimum-cost-path based algorithm (optimal parsing) to provide significantly better compression ratios than standard zlib level 9. You should test different levels to find the optimal balance between speed and ratio for your specific data.
In scenarios like Digital Content Creation (DCC) tools (e.g., Nuke or Katana), you may need to link a custom plugin against a different version of OpenEXR than the one used by the host application. To prevent symbol clashes, use the following strategies:
Configure your custom build of OpenEXR with a unique namespace so its symbols do not collide with the host's symbols.
Because OpenEXRCore is implemented in C and does not support a namespace option, you must use a specific CMake flag to hide its symbols. This prevents the OpenEXRCore symbols in your plugin from clashing with the host's symbols.
Requirement: Build your custom OpenEXR library with:
-DOPENEXR_FORCE_EMBEDDED_CORE=ON
Effect: This links against a statically-built OpenEXRCore library with hidden symbols. Note that the installation will not include a libOpenEXRCore.so file.
Limitation: This solution works if your plugin uses the OpenEXR C++ API. If your plugin requires direct access to the OpenEXR C API from OpenEXRCore, this method will not work, and you must use other symbol-hiding mechanisms.
-DOPENEXR_FORCE_EMBEDDED_CORE=ONTiled OpenEXR files can store multiple versions of an image at different resolutions, known as levels. The level mode determines how these levels are structured:
ONE_LEVEL: Contains only a single, full-resolution level. This is functionally equivalent to a scan line based file, but pixels are accessed via tiles.MIPMAP_LEVELS: Contains multiple levels where each successive level is half the resolution of the previous one in both x and y directions. The last level is a single pixel. Used for texture mapping.RIPMAP_LEVELS: Similar to mipmaps but includes all combinations of reducing resolution by powers of two independently in x and y. This helps accelerate anisotropic filtering.The size of each level is determined by halving the size of the higher-resolution level. The rounding direction (if the dimension is odd) is controlled by the file's level size rounding mode.