Colour is an open-source Python package providing a comprehensive number of algorithms and datasets for colour science.
It is freely available under the New BSD License terms.
Most of Colour's code is vectorised through Numpy, while trying to be as faithful as possible to the scientific publications implemented. Execution speed has never been the primary focus for the development, however, it is often an important factor to consider when adopting a library thus we would like to improve the general performance of Colour.
| Intensity | Priority | Involves | Mentors |
|---|---|---|---|
| Moderate/Hard | Medium | Implementing a benchmarking suite, investigating usage of CuPy, Bohrium or any relevant GPU backend (e.g., OpenCL), measuring performance, and finally based on the initial investigation, improving speed in image processing hotspots. | Michael Mauderer, Thomas Mansencal |
Performance measurements require the creation of a benchmarking suite that can quantify the improvements. Airspeed Velocity (ASV) is a tool for benchmarking Python packages, used by scikit-image and would be a suitable candidate. The benchmark should ensure that basic colour conversions (e.g., CIE XYZ to CIE Lab) run with a good performance when processing large images, e.g. HD1080, UHD resolution. At this stage, we are interested in trying out drop-in improvements like CuPy and Bohrium: they offer an almost drop-in Numpy like API. They might provide significant performance improvement to the whole library for a minimal amount of work. We are also open to evaluating manual improvements su as re-implementing algorithms directly with Cython, Rust or OpenCL.
- Experience with testing or benchmarking numerical code
- Knowledge of Numpy, Scipy, vectorisation and GPU programming
- Basic knowledge of Colour
- Investigate Airspeed Velocity
- Design and implement a benchmarking suite for Colour
- Discuss with the Colour developers about the preferred transformations to measure the performance of and benchmark them
- Investigate possible optimizations and GPU backends
Colour implements various Colour Appearance Models (CAM), most notably Hunt, CIECAM02 and CAM16. More models would be useful for research purposes, especially for High Dynamic Range (HDR) image processing.
| Intensity | Priority | Involves | Mentors |
|---|---|---|---|
| Moderate | High | Implement new Colour Appearance Models. | Michael Mauderer, Thomas Mansencal, Hao Xie |
Colour appearance modeling is critical to the prediction of colours under different viewing conditions. The current model recommended by the CIE is CIECAM02 and is not designed to process HDR imagery. Sadfar et al. (2018) proposed a new CAM based on JzAzBz colourspace with support for HDR imagery. Other CAMs such as iCAM06, Kim, Weyrich and Kautz (2009), the Comprehensive CAM, and CAM15u are also prime candidates for addition.
- Colour science and colour appearance modeling
- Ability to read scientific publications
- Knowledge of Numpy and Scipy
- Basic knowledge of Colour
- Study the
colour.appearancesub-package - Implement Sadfar et al. (2018) CAM forward and reverse transformations
- Implement the remaining CAMs in the preferred following order:
- iCAM06
- Kim, Weyrich and Kautz (2009)
- Comprehensive CAM
- CAM15u
The CIE current recommended method for measuring Colour Quality is the CIE 2017 Colour Fidelity Index (CFI 2017). It supersedes the Colour Rendering Index (CRI) and should be implemented in Colour along with the related ANSI/IES TM-30-18.
| Intensity | Priority | Involves | Mentors |
|---|---|---|---|
| Moderate | High | Implementing new colour quality metrics and learning about colour fidelity | Michael Mauderer, Thomas Mansencal |
Colour implements the SSI, CRI and CQS quality metrics, the two latter have been superseded with ANSI/IES TM-30-18 and CFI 2017. To bring Colour up to latest standards, those two metrics need to be implemented. Leveraging that those new metrics, an exhaustive light quality report using new plotting definitions should be implemented.
- Colour science and colour quality
- Ability to read scientific publications
- Knowledge of Numpy and Scipy
- Basic knowledge of Colour
- Study the
colour.qualitysub-package - Implement ANSI/IES TM-30-18
- Implement CFI 2017
Spectral upsampling (or recovery) is the conversion of CIE XYZ tristimulus values (or RGB values) to the spectral domain. Colour already implements Smits (1999) and Meng et al. (2015) methods and would benefit from the latest research algorithms.
| Intensity | Priority | Involves | Mentors |
|---|---|---|---|
| Moderate | High | Implement new spectral upsampling methods and learning about spectral computations | Michael Mauderer, Thomas Mansencal |
Spectral representation and processing is critical to faithfully model metamerism and accurately produce radiometric quantities. Unfortunately, spectral data is not widespread and spectral imagery even more so, while imposing huge acquisition and processing constraints. Spectral upsampling is used in modern research rendering systems such as PBRT and Mitsuba or production renderers such as Manuka to convert input colours and textures to the spectral domain. Research is active around this topic with recent publications from Otsu et al. (2018), Jakob and Hanika (2019), Mallett and Yuksel (2019) or Peters et al. (2019). Colour would highly benefit from having those algorithms implemented.
- Colour science and spectral rendering
- Experience in numerical optimization
- Knowledge of Numpy and Scipy
- Basic knowledge of Colour
- Research the latest publications and literature on spectral upsampling
- Study the
colour.recoverysub-package - Implement support in priority for Otsu et al. (2018) and Jakob and Hanika (2019) methods
- Implement support for Mallett and Yuksel (2019) and Peters et al. (2019) in a second time, and if only nothing significant was highlighted in recent research.
Gamut mapping is a core component for any colour management system. Direct support in Colour for display-referred centric Gamut Mapping algorithms such as that given by Morovic and Luo (2000) has been requested on a few occasions. Coincidentally, the A.M.P.A.S. has started an initiative about scene-referred Gamut Mapping. The techniques might be different but the core principles are the same: mapping colours from a larger solid of colour within a smaller solid while producing faithful and plausible values.
| Intensity | Priority | Involves | Mentors |
|---|---|---|---|
| High | High | Implementing support for gamut mapping and learning about gamut boundary and its description | Michael Mauderer, Thomas Mansencal |
Gamut mapping is usually implemented as a two step process. First, the boundaries of the two gamuts of interest are computed, producing two Gamut Boundary Descriptors. Then, colours of the larger solid are mapped within the smaller solid, commonly via raycasting. CIE 156:2004 provides guidelines covering numerous aspects of GMA evaluation including test images, media, viewing conditions, measurement, gamut boundary calculation, gamut mapping algorithms, colour spaces and experimental method. Some preliminary work was started by the Colour Developers in the feature/gamut_mapping branch and the generation of the Gamut Boundary Descriptor is in a decent state.
- Colour science and computer graphics
- Experience with meshing and tesselation
- Experience with raycasting and raytracing
- Knowledge of Numpy and Scipy
- Basic knowledge of Colour
- Study the relevant literature, e.g. Morovic and Luo (2000) and CIE 156:2004
- Pull down the feature/gamut_mapping branch and study the
colour.gamutsub-package - Complete the Gamut Boundary Descriptor implementation
- Implement various gamut mapping methods
| Intensity | Priority | Involves | Mentors |
|---|---|---|---|
| Moderate | High | Improving LUT input/output capabilities and learning about lookup tables | Michael Mauderer, Thomas Mansencal |
Colour offers good support for lookup table (LUT) input and output but several features could be implemented to improve the current capabilities:
- Support for LUT inversion
- CLF 3 support
- Implement a Log2 shaper as per OCIO reference
- Implement an ExponentWithLinear function
- Implement a generic parameterised camera log function
- Document how to bake a shaper + LUT combo
- Fix the various minor CSP LUT issues
- Ensure that the
colour.LUT_to_LUTdefinition handles explicit domains - Fix the
.spi3dLUT indexing on read as per OCIO reference
- Knowledge of Numpy and Scipy
- Basic knowledge of Colour
- Study the
colour.io.lutssub-package - Address one of the fixes or implement one of the minor features