OpenVPCal Calibration Workflow & Operation Guide

1. Workflow Overview

2. UI Breakdown

2.1. LED Settings Panel

This panel is used to configure the current state of the LED wall, including gamut, EOTF, and peak luminance.

2.1.1. LED Target Settings

• TARGET GAMUT: Select the target gamut for calibration. You can choose from predefined standard gamuts such as sRGB, P3, and Rec.2020.
• ADD CUSTOM GAMUT: Clicking this button opens a window where you can define a new custom gamut by entering a name and its CIE 1931 x,y primary and white point coordinates for use in calibration.
• TARGET EOTF: Select the target EOTF for the LED panel.
• TARGET MaxLum (nits): Sets the peak luminance of the content — only available when the EOTF is ST2084.
• (In Add Custom Gamut) CUSTOM NAME: Defines the name for the custom target color space.
• (In Add Custom Gamut) TARGET GAMUT CHROMATICITY COORDINATES: View or modify the xy gamut primaries and white point coordinates.
  

2.1.2. Tool Settings

• NUMBER OF GREY PATCHES: Sets the number of grey steps to generate / analyze. Default is 33.
• PRIMARIES SATURATION: Sets the saturation intensity for the color primaries. Default is 0.7.

2.2. Test Pattern Settings

This section is used to configure metadata about the test pattern. It won’t be enabled until after shooting is complete and the images have been imported.

2.3. Plate Settings

2.3.1. Plate Settings

• INPUT PLATE GAMUT: The input color space for the pre-processed camera plate sequence. Default is ACES 2065-1. This refers to the color space of the image itself.
• NATIVE CAMERA GAMUT: The native color space of the camera used for the shoot. This is the camera’s original gamut at the time of shooting. Even though the plate has already been converted, OVC still wants to know this.
• AUTO WB SOURCE: If enabled, the input plate will be auto-white-balanced before analysis and calibration. Strongly not recommended to enable.
  

2.3.2. Reference Settings

(In a complex shoot scenario with LED walls of different models or batches, you may need to match the calibration of one wall to another that is already calibrated or serves as a reference standard. By checking “Match Reference Wall” in the Reference Settings and selecting the corresponding reference wall from the dropdown, OpenVPCal will adjust the parameters of the wall being calibrated during the process, making its color output, luminance, and so on as consistent as possible with the reference wall. This allows for coordinated matching across multiple walls, ensuring visual consistency throughout the shoot.)

• MATCH REFERENCE WALL: If checked, the selected LED wall will be matched to the chosen reference wall.
• REFERENCE WALL: Lists the available reference walls that can be used for matching.
  

2.3.3. White Point Offset

Upload an EXR image so that OpenVPCal can calibrate against that white point reference.

• USE WHITE POINT OFFSET: If checked, the plate’s original white point will be shifted toward the measured white point of the specified file before analysis and calibration.
• WHITE POINT OFFSET SOURCE FILE: Path to the file containing the white point offset source.

3. Detailed Workflow (following the order in the overview)

3.1. Setting Up Test Content

3.1.1. Create a Project

When you launch the application, a dialog will automatically pop up asking whether you want to create a new project or load an existing one. You can also click “New Project” after a project is already open.

3.1.2. Set Up the LED Wall

You’ll need to add the appropriate number of walls based on your calibration requirements. The concept of a “wall” depends on your specific use case — it might represent a combination of different cameras with the same physical LED panel, or different calibration passes.

My recommendation is to name them in the format “LEDName_CameraName,” which makes it clear this is a calibration for a specific LED-camera combination. When there are multiple cameras in the scene, you can duplicate entries to create multiple LED wall + camera combinations.

3.1.3. Export Calibration Patches

Before exporting, make sure the LED settings in OpenVPCal are correct, because the color values in the calibration patches need to be properly encoded. You can configure the patch file format, resolution, and number of frames per patch in the “Patch Generation” tab of the Project Settings widget. For example, when using Unreal Engine’s media player, exporting as linear EXR is generally more convenient; for systems like Disguise or Plate Performer, exporting display-referred patches as DPX may be more appropriate.

If EXR is selected as the file format, the generated patches will bypass the EOTF (exported as linear), with a scale of 1 = 100 nits (meaning a value of 1 in the image represents 100 nits of brightness), encoded in the target color space.

3.1.4. Load Calibration Patches into the Media Player

Upon export, OpenVPCal also generates a Pre_Calibration_OpenVPCal.ocio config file, which provides the necessary transforms to be applied to the patches — this is especially important when exporting EXR.

The Pre_Calibration_OpenVPCal.ocio config provides three transforms (to be used as output transforms):

1. First option: EOTF transform only
2. Second option: EOTF + gamut transform
3. Third option: Gamut transform only (choose this for the EXR + UE playback workflow)

For the nDisplay output, configure it as follows: set the input to WorkingColorSpace (UE), which means no color transform is applied to the colors inside UE. (That said, it’s recommended to change UE’s working color space to BT.2020, so internal processing uses a richer color range. If you’ve selected Rec.2020 as the color space, your input can also be “Linear ITU-R2020.” Ideally, you’d pick ACES AP1 / ACEScg here, but that might cause issues with…)

This is a standard OCIO setup for shooting test patches.

Unreal Post-Processing Settings:
(Refer to the exported Word document — advanced macros are not supported in Tencent Docs display.)

3.1.5. Camera Setup

Camera setup details (to be filled in later).

3.2. Calibration

3.2.1. Pre-Process the Test Plate

Pre-process via DaVinci Resolve.

3.2.2. Load the EXR Sequence

In OpenVPCal’s “Stage View” > “LED Wall” panel, right-click the LED wall you want to load the plate for and select “Load Plate Sequence,” or go to “File” > “Load Plate Sequence,” to load the calibration test plate corresponding to that wall.

OpenVPCal will automatically recognize the test plate and attempt to determine the region of interest (ROI) for analysis as well as the gaps between patches. If auto-detection fails, you can manually align the red ROI rectangle in the viewer using the center square of the first patch as a reference.

3.2.3. Plate Settings

• Input Plate Gamut: This must always be a linear space (e.g., ACES 2065-1).
• Native Camera Gamut: For example, ARRI Wide Gamut or Sony SGamut.
• Auto White Balance: Not recommended. Enabling this applies automatic white balance to the image, which defeats the purpose of white balance calibration. (If your workflow requires auto white balance on the plate and you can’t do it in-camera, or if you need more precise white balance, then go ahead and select the Auto WB Source.)

3.2.4. Analyze

After loading and setting up the plates for each LED wall you intend to analyze and calibrate, click “Analyze” in the Execute tab.

The analysis operation extracts the necessary information from the plate and switches the software to “Analysis Layout.” You can select multiple walls and run the analysis simultaneously. (Note: any wall that uses another wall as a reference must be analyzed and calibrated at the same time as that reference wall.)

When the analysis completes, the tool displays a popup window summarizing the results for each analyzed wall. The analysis may report critical errors, warnings, or indicate that the wall does not require calibration (because it falls within acceptable tolerance).

3.2.4.1. Sample Analysis Viewer

In the analysis layout, a patch analysis viewer appears, giving you an overview of the wall’s state and its calibration. The viewer is powered by OpenColorIO (OCIO), so patches can be mapped to any color space available in the default OCIO config bundled with the tool — ACES 1.3 Studio Config.

The viewer renders each patch in the calibration sequence as a square swatch: the outer area shows the target color, and the inner area shows the actual color as captured by the camera.

• Correct example:
  
• Example of a capture error:
  
• Note that the red, green, and blue positions are swapped.

What each control does:

• Exposure slider: Adjusts the exposure level of the image in the patch analysis viewer.
• Display and view drop-down menus: “Display” selects which screen to view on. “View” selects what type of data to display.
• Auto white balance preview: Lets you preview how the auto white balance algorithm would adjust the patch colors before committing.
• Calibration preview: Shows the expected result of applying calibration to the patches.

3.2.4.2. Analysis Widgets

• Max Distance Analysis: Shows the extent of out-of-gamut colors relative to the calibration target color space, both before and after calibration.
• EOTF Analysis: Tracks the linear response of the LED wall, showing pre- and post-calibration data for the red, green, and blue channels.
• White Point Analysis: Displays the LED wall’s white point as observed by the camera, including the target white point, pre-calibration white point, post-calibration white point, and the white point from the Macbeth samples.
• Color Space Analysis: Shows the LED wall’s color space and white point range as observed by the camera, covering the target color space, pre-calibration color space, post-calibration color space, and Macbeth sample data.

The Macbeth Color Checker is a standard color reference chart produced by Gretag Macbeth, a brand under X-Rite. It consists of a series of patches with precisely defined colors and reflectance values, measured and standardized to serve as a color calibration reference, helping ensure color accuracy and consistency across different devices and environments.

3.2.4.3. IPT — Color Difference Analysis Widget

This widget uses the DeltaE metric to evaluate calibration accuracy. DeltaE is a metric that quantifies the perceptual difference between two colors. In this context, it measures the difference between the colors captured by the camera (before and after calibration) and the target colors. This analysis gives you a clear picture of how effectively the calibration process reduces color error. A smaller DeltaE value means the camera-captured colors are closer to the target, indicating more accurate calibration. The widget may display these DeltaE values in graphical or numerical form, helping you quickly assess how different color regions — or the entire color space — change before and after calibration. For example, it might show the DeltaE value for each individual patch before and after calibration, or provide an average DeltaE across the entire chart as an overall quality measure.

3.2.5. Calibration Settings

3.2.5.1. Calibration Options

The calibration settings offer a range of options supporting different calibration paths and features. The analysis process typically sets optimal parameters based on the condition of the LED wall, but you can also manually enable or disable options or choose a different path. The options are as follows:

• REFERENCE TO TARGET CAT: Select from a list of standard chromatic adaptation transforms.
• CALCULATIONS ORDER: Edit the operation order of the calibration transforms. Gamma calibration first, or color space calibration first.
• ENABLE EOTF CORRECTION: Check this to enable EOTF correction.
• TARGET TO SCREEN CAT: Select a chromatic adaptation transform from the standard list, or select “NONE” to use it as the calibration matrix. Default is “NONE.”
• ENABLE GAMUT COMPRESSION: Check this to enable gamut compression.
• AVOID CLIPPING: Check this to scale the entire calibration transform so highlight clipping is avoided (enabled by default).

Note: As of 2025-02-05, there is a bug in the OpenVPCal UI where the checked options may not be reliable — always verify against what’s actually written in the OCIO config file. If Gamut Compression is enabled, the transform in the config will include additional lines like these:

3.2.5.2. Calibration Order (Calculations Order)

1. EOTF CORRECTION DISABLED:
   • Calibration method: In this path, calibration is performed solely through a 3x3 matrix applied directly to the input RGB data that has been converted to the target color space.
   • Assumption: This approach assumes the LED wall behaves linearly — meaning there is a simple linear relationship between the input signal and the wall’s luminance and color output throughout the image processing pipeline. No EOTF correction is needed.
2. 1D → 3x3:
   • Calibration method: During calibration, EOTF correction and RGB balance are measured first, then the 3x3 calibration matrix is applied.
   • Assumption: This path assumes the LED wall is not linear, and that the non-linearity occurs at the end of the image processing chain. This means that after color mapping, the LED wall’s own characteristics introduce non-linear luminance or color output, so EOTF correction and RGB balance adjustments need to happen before the 3x3 matrix calibration.
3. 3x3 → 1D:
   • Calibration method: The reverse of 1D → 3x3 — the 3x3 calibration matrix is applied first, then EOTF correction and RGB balance are measured.
   • Assumption: Also assumes the LED wall is non-linear, but here the non-linearity is assumed to occur at the beginning of the image processing chain (before or during pipeline color mapping, before the EOTF). That is, the non-linearity already exists at the early color mapping stage (the UE rendering stage), so the 3x3 matrix is used first to do a preliminary color space correction, followed by EOTF correction and RGB balance.
4. Which one to choose:
   • The correct choice depends on where the non-linearity occurs in your specific image processing pipeline. Different LED wall hardware, image processing software, and hardware configurations can cause non-linearity at different stages.
   • When the analysis determines that the LED wall is not linear, OpenVPCal defaults to the 1D > 3x3 order. This is because in most common situations, the LED wall’s non-linearity is more likely to occur at the end of the processing chain, making this order the more commonly applicable choice.

3.2.5.3. Chromatic Adaptation Transform

A chromatic adaptation transform (CAT) is a mathematical transform that simulates the human visual system’s ability to adjust color perception under different lighting conditions. In color management and calibration, CAT becomes especially important when converting colors between different illuminants or color spaces.

For example, when converting from a color space with a specific white point (such as daylight) to one with a different white point (such as tungsten lighting), a CAT ensures that colors remain visually consistent — even though the illuminant has changed, a human observer should perceive roughly the same colors.

In OpenVPCal, CAT is used throughout the calibration process to help map colors accurately between different reference standards and target color spaces. In the Calibration Settings widget, users can select an appropriate transform from the standard CAT list — for example, the “Bradford” transform, which is one of the most widely used CAT algorithms. Different CAT algorithms may perform better in different scenarios, so choosing the right one helps improve the accuracy of color calibration.

• Reference to Target: Here, “Reference” refers to the test plate’s ACES 2065-1 space, and “Target” refers to the target gamut of the screen.
• Target to Screen:
• 
• Adjusts the test plate’s original white point to match the target screen’s white point. As a result, the calibration output will not change the screen’s white point.

3.2.5.4. Avoid Clipping

The calibration process may push one or two RGB channels above the expected peak luminance. When targeting the ST2084 EOTF, if any channel exceeds that value, the display will clip it, which affects the LED wall’s white point. The “Avoid Clipping” feature scales those channels back down below the peak luminance threshold. This may have a slight effect on the overall brightness of the LED wall, but the impact should be fairly minor.

3.2.5.5. Calibration Matrix

Once calibration is complete, this widget provides options to copy each 3x3 matrix used in the calibration transform in several useful formats.

3.3. Transform Breakdown

3.3.1. Detailed Breakdown of the OCIO Transforms

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1- !<ColorSpace>
2 name: Calibration CSC - UP - S-Gamut3.Cine - EOTF_CS
3 family: OpenVPCal/Utility
4 equalitygroup: ""
5 bitdepth: 32f
6 description: |
7 Colourspace for OpenVPCal.
8 EOTF correction assumes signal 1.0 represents 100 nits
9 Configuration---
10 target_EOTF--ST 2084
11 target_gamut--ITU-R BT.2020
12 calculation_order--EOTF > CS
13 enable_plate_white_balance--False
14 enable_gamut_compression--True
15 enable_EOTF_correction--True
16 isdata: false
17 encoding: scene-linear
18 allocation: uniform

This section contains the description and metadata. For the final confirmation of all settings, always trust this block rather than the UI. It’s located around line 1150. The calculation_order field here determines the order of the two main transforms below.

1
2
3
4
5
6
7
8
9

1from_scene_reference: !<GroupTransform>
2 children:
3 - !<MatrixTransform> {matrix: [1.49040952046417, -0.2661709192612, -0.224238601333507, 0, -0.080167499789956, 1.18216712107567, -0.101999621238164, 0, 0.00322763118916624, -0.0347764757444135, 1.03154884460315, 0, 0, 0, 0, 1]}
4 - !<MatrixTransform> {matrix: [1.15939307498367, -0.0669171977606114, 0.121386208480261, 0, 0.0937843467518664, 0.750274773384815, 0.0937843467736498, 0, -0.0460361329355286, 0.0651114229039448, 0.627884921201905, 0, 0, 0, 0, 1]}
5 - !<GroupTransform>
6 children:
7 - !<BuiltinTransform> {style: CURVE - LINEAR_to_ST-2084}
8 - !<FileTransform> {src: EOTF Correction 1D - UP - S-Gamut3.Cine - EOTF_CS.clf, direction: inverse}
9 - !<BuiltinTransform> {style: CURVE - ST-2084_to_LINEAR}

The two main transforms are: MatrixTransform for gamut conversion, and the GroupTransform children for gamma calibration.

• The first transform — !<MatrixTransform> {matrix: [1.49040952046417, -0.2661709192612, -0.224238601333507, 0, -0.080167499789956, 1.18216712107567, -0.101999621238164, 0, 0.00322763118916624, -0.0347764757444135, 1.03154884460315, 0, 0, 0, 0, 1]} — is the ACES AP0 -> BT.2020 gamut conversion. I’m confident about this because I verified it by calculating it myself: . In the OpenVPCal UI, this corresponds to the Reference To Target Matrix. So “Reference” refers to ACES AP0, and “Target” refers to the “target gamut” (BT.2020 in this case).
• The second transform is: the Target To Screen Matrix. This is presumably the transform that corrects for the screen’s color cast relative to BT.2020 — i.e., X * matrix = the color cast correction to BT.2020.
• The children transforms below: EOTF calibration using a 1D LUT, applied separately to the R, G, and B channels.

1
2
3
4
5
6
7

1 // The following is added if Gamut Compression is enabled
2 - !<GroupTransform>
3 children:
4 - !<BuiltinTransform> {style: ACEScg_to_ACES2065-1}
5 - !<FixedFunctionTransform> {style: ACES_GamutComp13, params: [1.08919025420343, 1.001, 1.03970709669469, 0.9, 0.9, 0.9, 4]}
6 - !<BuiltinTransform> {style: ACEScg_to_ACES2065-1, direction: inverse}
7 // The above is the added section

Gamut compression. See the ACES Gamut Compression and User Guide for details.

1

1!<MatrixTransform> {matrix: [1.49040952046417, -0.2661709192612, -0.224238601333507, 0, -0.080167499789956, 1.18216712107567, -0.101999621238164, 0, 0.00322763118916624, -0.0347764757444135, 1.03154884460315, 0, 0, 0, 0, 1], direction: inverse}

This is the inverse of the first gamut conversion matrix from the two main transforms above.

3.3.2. Alternative if OCIO Is Not Available

In the same directory as the output OCIO config, there is a LUT CUBE file.

This file combines the matrix transforms and the 1D LUT. It can be used in environments that don’t support OCIO, such as Disguise. It should be applied at the very end of the image processing pipeline, just before the signal is sent to the LED wall.

3.3.3. Two Post-Calibration Transforms

After calibration is complete, there are two calibrated transforms available — one in Desired Color Spaces and one in Desired Display-Views:

Desired Color Spaces:

Use WorkingColorSpace + this for the output to screen:

Desired Display-Views:

Use WorkingColorSpace + this for the output to screen:

The second option (Display-Views) is clearly the correct one. Looking at the code, the Color Spaces option actually contains one extra transform on top of what Display-Views does. After completing the ColorSpace and linear calibration, the original transform converts back to AP0 — and this one tacks on an additional step to convert to CIE-XYZ. That’s likely used for generating chromaticity diagrams.

3.3.4. How Gamut Compression Parameters Are Calculated

This code lives in the colourspace_max_distances function inside src/open_vp_cal/core/calibrate.py.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

1def colourspace_max_distances(source_cs, destination_cs, cat, shadow_rolloff):
2 # Input: source_cs — source color space (target color space)
3 # Input: destination_cs — destination color space (screen color space)
4 # Input: cat — chromatic adaptation transform method (e.g., CAT02, Bradford)
5 # Input: shadow_rolloff — rolloff transition parameter
6
7
8 # 1. Build an RGB primaries matrix and convert between color spaces
9 primaries = colour.RGB_to_RGB(
10 # Create a unit RGB primaries matrix: red [1,0,0], green [0,1,0], blue [0,0,1]
11 RGB=np.asarray([[1.0, 0.0, 0.0], # Red primary
12 [0.0, 1.0, 0.0], # Green primary
13 [0.0, 0.0, 1.0]]), # Blue primary
14 input_colourspace=source_cs, # Source color space (e.g., BT.2020)
15 output_colourspace=destination_cs, # Destination color space (e.g., display color space)
16 chromatic_adaptation_transform=cat # Chromatic adaptation transform method
17 )
18
19 # 2. Calculate achromatic (greyscale) values — this is where data differences can arise
20 achromatic_values = np.apply_along_axis(
21 lambda rgb: achromatic(rgb, shadow_rolloff), # Calculate achromatic value for each RGB
22 1, # Apply along axis 1 (rows)
23 primaries # Input data
24 )
25 # What the achromatic function does:
26 # - Takes the max value from RGB
27 # - Applies shadow rolloff if the value is below shadow_rolloff
28 # - Returns a greyscale value in the form [value, value, value]
29
30 # 3. Calculate distances
31 distances = (achromatic_values - primaries) / achromatic_values
32 # This calculation represents:
33 # - The difference between the achromatic value and the primary value
34 # - Normalized to the achromatic value range
35
36 # 4. Return the max distance per channel
37 return np.amax(distances, axis=0)
38 # Returns the max distance value for each color channel (R, G, B)

The impact of these values is discussed around the 13:54 mark in the video — it relates to the ACES Parametric Gamut in the ACES standard color transforms.

The purpose is to prevent color overflow (clipping) after gamut conversion. Specifically, if the colors “exceed the LED wall’s display capability” but fall within the camera’s capture range, the camera will see color clipping. This is addressed by compressing the color space by roughly 10%.

Parameter example:

1
2
3

1- !<BuiltinTransform> {style: ACEScg_to_ACES2065-1}
2- !<FixedFunctionTransform> {style: ACES_GamutComp13, params: [1.10245316504887, 1.001, 1.001, 0.9, 0.9, 0.9, 4]}
3- !<BuiltinTransform> {style: ACEScg_to_ACES2065-1, direction: inverse}