BE1030282B1 - METHOD FOR NONLINEAR COMPENSATION IN DISPLAY APPLICATIONS - Google Patents

Abstract

The invention relates to displays, including for example LED (light-emitting diode) displays, but is not limited thereto. More specifically, the invention relates to obtaining more accurate color and/or grayscale representation in such displays by means of correction methods based on compensating for non-linearities (caused by pixel drivers).

Description

1 BE2022/5881

METHOD OF NONLINEAR COMPENSATION

IN DISPLAY APPLICATIONS

Technical field

The invention relates to displays, such as LED (light-emitting diode) displays, but is not limited to this specific display technology. More specifically, the invention relates to obtaining more accurate color and/or grayscale representation in such displays by means of (non-linear) correction or compensation methods, even and in particular applied after calibration (based on linear equations) , but also when no calibration has been applied.

Background of the invention

From the previous disclosures and applications, it has become clear that when calibrating a display (or monitor) for color and brightness, uniformity must be performed in real time. For LED displays - to this day - all calculations are made in the linear color space and do not take into account non-linearities that exist in generating the respective light output of the individual R(red), G(green) and B(lukewarm) color per individual pixel.

The light output of traditional LEDs is generated using PWM (Pulse Width

Modulation) that acts on constant current drivers (generally pixel drivers, possibly also called PWM drivers or LED drivers). It is well known in the LED industry (see e.g. "Handbook of Visual Display Technology": Thielemans R. (2012) LED Display Applications and

Design Considerations — Springer, Berlin, Heidelberg. https://doi.org/10.1007/978- 3-540- 79567-4 76) that LEDs change color slightly when the drive current is changed. So a constant current is applied. However, for various reasons, linearity between digitally generated PWM and measured light output on the individual LEDs is not guaranteed. This means that the 'traditional'

X,Y,Z color correction calculations (e.g. known as standard calibration, usually calculated in linear space) that operate on PWM and the assumed 'constant current drivers'

2 BE2022/5881 are not entirely correct. Further correction or compensation (for non-linearities) is therefore necessary.

Description of the background (regarding calibration)

More detailed background is now provided, for which reference may also be made to previous patent applications by the same Applicant, i.e. US patent application publication US2020/0286424, entitled "REAL-TIME DEFORMABLE AND TRANSPARENT DISPLAY" and published on September 10, 2020.

While each individual LED may differ in e.g. color or brightness, calibration is considered important. The traditional calibration video pipeline in accordance with the technique is shown in Figure 1, which shows a flow for color output determination

Rout, Gout, Bout for the RGB primary colors based on the calibration matrix (A), if determined, and on the color input Rin, Gin, Bin for the RGB primary colors as received. As shown here in Figure 1, the calibration values for each RGB pixel are retrieved from a memory location depending on the position (row, column) of the pixel itself. As a final step here in the flow, a temperature correction can be applied to achieve even better color rendering. The calibration principle of making light-emitting elements (e.g. LEDs, OLEDs) or pixels appear uniform on a screen is common, as is the math behind it. This principle is based on individual measurements at a certain drive current for each pixel in the display. As an example, the mathematical principle is explained in more detail for traditional ones

RGB LEDs, but it could also be applied to any other LED cluster with certain colors.

Assume that all RGB LEDs were measured at a certain defined current and defined temperature. This measurement can be done with e.g. a spectrometer. This provides x, y and Y readings for each of the R, G and B colors in one LED. In the case of an RGB (Red, Green, Blue) display, the measurements are e.g. performed in the CIE 1931 color space, with each color represented in (x, y) and Y, for example (x,y,Y are converted to X,Y,Z for working in linear space):

Rin = (Rinx, Riny, RinY) = (RinX,RinY,RinZ)

3 BE2022/5881

Gin = (Ginx,Giny,GinY) = (GinX,GinY,GinZ)

Bin = (Binx,BinY,BinY) = (BinX,BinY, BinZ)

It is noted that (x, y) are normalized values of X, Y and Z which are the so-called tristimulus values, while Y is a measure of the brightness of a color.

Red Green Blue 0.6859 198.70 |0.215 |0.7171 | 250.00 |0.131 |0.107 | 66.00 439.64 | 198.70 74.95 | 250.00 | 23.67 |80.80 | 6600 | 470.02

RinX GinX BinX 43964 7495 80.80

Or in matrix format: |RinY GinY BinY| =|198.70 250.00 66.00

RinZ GinZ BinZ 2.63 23.67 470.02

Color conversions are performed using the following formulas:

x x=

X+Y+4Z

Y

YOUR XFY+Z

Z 1 z=—_ = —X-—

X+Y+Z y x

X=Y- y z=L (1 ) =— xy y

Now you can define what the color targets should be. (Standards have been defined for e.g. HDTV, NTSC, PAL, REC2020…) These are the real colors that should be shown on the display.

Red Green Blue

NTSC 1953

Adobe RGB 98 | 0.64 |033 |1 [022 [071 |1 [01 |006 |1

PAL |o63 |033 |1 |03 |06 |1 |015 |006 |1

4 BE2022/5881

So all LEDs must be 'calibrated' to these individual points, as explained earlier.

One can set the colors according to these standards, but it is not a must because the mathematics is general.

Target Red color can be defined as:

Rtarg = (Rtargx,Rtargy,RtargY) = (RtargX,RtargY,RtargZ)

The linear relationship between the target values and the 'measured values' can then be defined (example here for Red channel).

RonR means how much red of the native LED should be used in the desired (target) color Red. GonR means how much Green of the original LED color to add to this Red, and so on.

RtargX = RinX x RonR + GinX x GonR + BinX x BonR

RtargY = RinY x RonR + GinY x GonR + BinY x BonR

RtargZ = RinZ x RonR + GinZ x GonR + BinZ x BonR

Or in matrix form this becomes:

RinX GinX BinX RonR RtargX

RinY GinY BinY | x |GonR| = |RtargY

RinZ GinZ BinZ BonR RtargZ

Performing this also for Green and Blue leads to the following matrix formula:

RinX GinX BinX RonR RonG RonB RtargX GtargX BtargX

RinY GinY BinY|x|GonR GonG GonB|= |RtargY GtargY BtargY

RinZ GinZ BinZ BonR BonG BonB RtargZ GtargZ BtargZ

Since the inputs are known and targets are known, the matrix can be solved for RonR etc.:

RonR RonG RonB (A) = |GonR GonG GonB

BonR BonG BonB

RinX GinX BinX] * [RtargX GtargX BtargX = in Giny pin x |Reargr GtargY Bua

RinZ GinZ BinZ RtargZ GtargZ BtargZ

The targets can look like this: 5 (note here that the brightness Y for all targets is normalized to 1)

Red Green Blue 064 [033 [100 [030 |060 |100 |014 [012 [100 194 |100 [009 [050 [100 [017 |117 [1400 [617

We already know that from above

RinX GinX BinX 439.64 7495 80.80 in GinY pin is: se 250.00 66.00

RinZ GinZ BinZ 2.63 23.67 470.02

RinX GinX Binx]”

So RinY GinY BinY becomes:

RinZ GinZ BinZ 0.002616 —0.00075 —0.00034 —0.0021 0.004658 000029 9.13E — 05 —0.00023 0.002144

And the final outcome for (A) then becomes:

RonR | 0.43% 0.05% 0.02% 0.06% 0.36% 0.04% 0.01% 0.02% 1.31%

Because the Y values in the targets have been normalized, additional information can now be added to not only set the LED calibrated colors to a target color, but use the brightness of each individual target color to set the display to a fixed white point when all RGB colors are enabled.

In this example, the display is set to the following white point:

6 BE2022/5881 0.423 0.399 480.00 508.87 480.00 214.14

RX GX BX R WX

RY GY BY|Xx|G|=|WY

RZ GZ BZ B WZ

WX, WY, WZ is the white point. The RX, GX, ... in this case is the target color matrix as these target colors will be used, and the brightness of the targets will be changed to achieve the correct white point. Therefore, the equation for RGB must be solved.

R] [RX GX Bx] [WX

G|=]RY GY BY]

B RZ GZ BZ WZ

RX GX BX 194 0.50 1.17 er GY ay then becomes: ra 1.00 100

RZ GZ BZ 0.09 017 6.17

RX GX BX]? 0.690697674 —0.332558 —0.07674 er GY ay then becomes: 0690418005 1.364535 008895

RZ GZ BZ 0.00872093 —0.031977 0.165698

R 175.4153 then becomes: [20.0120

B 24.5707

So now the final target with Y information added is: 175.4153 |0.30 |0.60 | 280.0140 24.5707

The last thing left to do is to apply (i.e. scale) the final multipliers to (A): 75.27% | RonR _|Gr |13.97% 0.44%

Rg | 9.68% 99.62% 0.98%

Rb | 2.48% 4.83% _|BonG |Bb | 32.18%

Note that Rr=RonR, Rg=GonR, Rb=BonR and

7 BE2022/5881 that Gr=RonG, Gg=GonG, Gb=BonG and that Br=RonB, Bg=GonB, Bb=BonB.

And this is the matrix (A) that can be used in the video pipeline of Figure 2, which represents a scheme that can be followed for the calculation of color output Rout, Gout,

Bolt based on the calibration matrix (A) and the color input Rin, Gin, Bin as received:

RonR RonG RonB (Rout, Gout, Bout} = [GonR GonG GonB|x (Rin, Gin, Bin)

BonR BonG BonB

It is noted that the scheme of Figure 2 is secured against locking by providing Rclip, Gclip, Bclip in case the maximum value is exceeded, or in case a negative result is achieved.

This explains the math for the 'simple calibration.

The next step is to make the calibration content-dependent through so-called content-dependent calibration.

The reason why this was invented earlier, as described for example in previous patent application US2020/0286424 from the same Applicant (and has now been extensively tested and implemented) is twofold: 1/ visual (perceptual problem) when calibrating blue colors, resulting in improvement of the perceptual color depth, and 2/ due to issues related to Blue calibration. Both will now be discussed further. 1/ Visual (perceptual problem) when calibrating blue colors, resulting in an improvement in perceptual color depth

The background of this invention is derived from the visual parameters explained in "Handbook of Visual Display Technology": Thielemans R. (2012) LED Display Applications and

Design Considerations - Springer, Berlin, Heidelberg. Here is a small summary of the factors of the human eye that have been quantified, but (as discussed later) not complete.

8 BE2022/5881 he Color perception of the human eye is most sensitive in the x-direction and less so in the y-direction (see, for example, MacAdam in “Handbook of Visual Display Technology”). However — and this has not yet been fully quantified — this assumes that all colors have the same brightness. When the brightness of colors is varied, it has been proven that the human eye's color perception changes, but there is no mathematics available for this. e In terms of resolution, or how people perceive the sharpness of a photo or image, it is most sensitive in the Red component. The least sensitive is the

Blue component. The best example to demonstrate this is reading blue text on a black background. This is much more difficult compared to reading red text on a black background. e The human eye is also not sensitive to gradual brightness variations. The best example is e.g. a projector or projector. The measured brightness in the corners is only 25% compared to the brightness in the center (100%). People will refer to this as 'uniform! experienced. Direct differences in brightness will be perceived much faster (within tolerance limits). 2/ Problems related to Blue calibration

Suppose you have 2 different blue LEDs that you want to calibrate to the same blue color target. To achieve the same target, a few Red and Green additions must be made to get the right color. When measured with a spectrometer (and also on some cameras), these LEDs will be perfectly aligned and both have the same X, Y and Z. However, when viewed by a human, the

Blue LED with most 'red' addition are perceived as almost dark, reddish compared to 'whitish' Blue LED where Green is added more. This phenomenon also depends on the viewing distance. The physical phenomenon that happens is that the 'human' eye 'locks' onto the narrow band red emitter (remember that the human eye is sensitive to 'resolution'). This 'locking' on the Red frequency means that perceived Blue components are no longer 'visible' and therefore produce a completely different visual perception. The CIE standard was created for broadband color emitters and not for narrowband emitters, so it does not take this 'perception' into account. Also - as mentioned earlier - it doesn't take brightness into account. So, although there is a lot of (proven) math

9 BE2022/5881 is available about colours, human perception is still 'king'. In conclusion we can say that although Blue LEDs can be calibrated to be completely identical according to CIE, the perception of color is still different.

On the other hand, a variation in brightness in Blue is perceived as a color variation and this is shown in Figure 3. The same RGB color in Blue with different brightness (0.0.152) denoted as B1 versus (0.0.255) denoted as B2 is deeper blue observed. And this color (0,0,255) B2 is 'visually' closer to (0,38,255) denoted as B3 compared to (0,0,152) B1, while technically (0,0,152) B1 and (0,0,255) B2 are the same colors are .

This means - for display calibration purposes - that in the event that Blue batches of colors need to be calibrated, brightness variations will be perceived much better! will produce uniformity. As a result, LEDs that require this Blue brightness variation require a different matrix. Hence the need for two matrices. But varying brightness of a target color (if used with R and G) causes the white point to change. So the LEDs that need Blue calibration by the

Changing blue brightness gives a completely different white point. This is not desirable at all.

Therefore, the solution is to use a factor that is content dependent. This factor determines when to use the 'Blue' matrix or the 'normal' matrix.

We now better understand that this principle is not only useful for 'calibrating' a display, but can also be used to improve color depth perception (and this also works on Green, Red...). As an example, it is known from the LED industry that traditional Blue LEDs are (often) not 'deep' enough in color. Usually they are above 470nm, while desirable is 460nm. Changing a 470nm Blue LED to play at low brightness gives the visual impression that it is playing at 460nm.

An important caveat is that as 'visual perception' is now brought into focus, the strict wording of 'calibrating' a display no longer applies here, as the word 'calibration' implies perfect/measurable uniform settings based on straightforward -straightforward measurements and mathematically correct adjustments.

10 BE2022/5881

We end with an example of how content-dependent calibration can be achieved while using the video pipeline shown in Figure 4, which shows a flow for determining the color output Rout, Gout, Bout for the primary colors RGB based on the calibration defined by 2 matrices Matrix1, Matrix2 and on the color input

Rin, Gin, Bin for the RGB primary colors as received. The final calibration matrix

Mfinal is then e.g. defined by these 2 matrices and their weight, defined by the so-called Factor. For example, we can have Mfinal = Factor x Matrix1 + (1-Factor) x Matrix2.

It is noted that the matrices (due to variations in LEDs) are different for each individual RGB LED. The example below is explained using one LED.

One defines a matrix to be used when only Blue is to be displayed (MBonly) and one defines a matrix when Blue is used while also

Green and Red are displayed (MBmix). The matrices are derived in the same way as previously explained in the 'traditional' example. To give an example here, the matrices can be derived by changing the target color brightness from Blue.

The target for MBmix uses the same target values as in the previous example (cf. white point): 0.64 |0.33 |175.4153 | 0.30 |0.60 |280.0140|0.14 [012 | 24.5707

And this produces the matrix MBmix:

Rr — |75.27% |RonR |Gr _ |13.97% |RonG |Br __ |044% |RonB

Rg | 968% | GonR |Gg | 99.62% |GonG |Bg |0.98% |GonB

Rb _|248% |BonR |Gb — | 483% |BonG |Bb — |32.18% |BonB

For the matrix Blue only (MBonly), the targets are set to: 0.64 |0.33 |175.4153 | 0.30 |0.60 |280.0140|0.14 [012 | 12.2854

This gives a completely wrong white point, but the target Blue is set to 50% in this example.

11 BE2022/5881

And this produces the matrix MBonly:

Rr — |75.27% |RonR |Gr _ |13.97% |RonG |Br __ |044% |RonB

Re [9.68% | GonR |G | 99.62% |GonG |Bg |0.98% |GonB

Rb [123% |BonR |Gb — | 240% |BonG |Bb —_|15.97% |BonB

Since only the brightness of target Blue has been changed, in this example only

BonR, BonG and BonB affected. It is up to the user's imagination to adjust and play with all kinds of settings. One can even change gradually, e.g. Blue to Green using this pipeline when a certain parameter in the content changes.

The next question to be answered is how to define when to use which matrix. Since we want to show a perceived deep Blue color in this example, the following is assumed: e MBonly should be used at 100% if the content to be shown is only blue e MBmix should be used at 100% if there is a substantial mix of Red and Green

The final matrix to be used is therefore:

Mfinal = Factor x MBmix + (1-Factor) MBonly

When Factor = 1, it means Mfinal = Mbmix. When Factor = 0, Mfinal = MBonly.

We then define a formula that takes into account the above assumptions and that we can also implement in real time:

Factor = max (2x(R+ G)/(R+G+B);1)

Factor = 0 when only Blue should be displayed. 0 < Factor < 1 when Blue has a 'little' involvement in the content to be shown.

Factor > 1 (clipped) when Blue has a substantial share in the mix of colors.

12 BE2022/5881

Many other formulas are conceivable, but this example has the advantage that it can be implemented quite easily in real-time FPGA calculations. Examples of

Factors can be found in the table in Figure 5.

Referring to the table of Figure 5, in case Red = 0.25, Green = 0 and Blue = 0.5 then Factor becomes 0.667.

The final calculation Mfinal then becomes: 75.27% | RonR _|Gr |13.97% 0.44%

Rg | 9.68% 99.62% 0.98%

Rb | 2.07% 4.03% _|BonG |Bb | 26.83%

Purpose of the invention

The aim of the invention is to look for a practical way to determine deviations due to non-linearities (caused by the pixel drivers) and then, once determined, how to correct or compensate (real-time) these deviations. The further intention is to define a physical (constant current driver) implementation (of the correction or compensation) that also reduces the calculation complexity in LED drive systems.

Summary of the Invention

In short, the invention provides a method for improved color and/or gray scale display of luminous displays by means of non-linear compensation, and furthermore electronic systems for implementing such a method, either globally (FPGA based), either locally (chip based).

In particular, recognizing that the use of calibration as known in the art (and which essentially assumes linear relationships) is insufficient, e.g. for high-quality display performance, an additional correction or compensation (due to non-linearities) must be determined and used. However, it must be said that even in the case where no calibration has taken place, non-linearities occur, and therefore a

13 BE2022/5881 correction or compensation required to obtain better color and/or grayscale output of video or images being displayed. In contrast to the standard calibration steps, which use (3x3) matrices performed per display pixel due to the interplay between (primary) colors, for the additional correction or compensation it may be sufficient to do this for only one (primary) color and per cluster of display pixels.

It is noted that the calibration may be dependent on a display content context and/or display arrangement, so content dependent calibration may be used as known in the art. The non-linear compensation can be based on the brightness (Y value of color space coordinates) defined by a mathematical formula. Alternatively, the compensation can rely on what is stored in one or more lookup tables (or memory), each consisting of input values and corresponding output values taking into account the non-linearities. Considering the amount of (required) storage space for the non-linear compensation, the use of multiple small lookup tables (with reduced bit representation) instead of a single large one can be suggested, including performing interpolation calculations between these small lookup tables. Further recognizing that the above may still be insufficient for high-quality display performance, an additional temperature correction may be applied.

For some aspects of the present invention further described below, reference may be made to a previous application by the same Applicant, including for example WO2019/215219 A1, entitled "STANDALONE LIGHT-EMITTING

ELEMENT DISPLAY TILE AND METHOD” and published on November 14, 2019, and

US2020/0286424, entitled “REAL-TIME DEFORMABLE AND TRANSPARENT DISPLAY” and published on September 10, 2020. Where it appears relevant to any aspect of the present invention, such reference will be made specifically and explicitly below.

According to a first aspect of the invention, a method is provided for determining non-linear display pixel driver compensation performed by a processing system of (or for) a light-emitting display characterized by one or more colors, said light-emitting display includes pixels controlled by pixel drivers. The 'assessment' method includes the following steps: (i) measuring (real-time) (on-display)

14 BE2022/5881 (color) values for at least one of the one or more colors (and/or one or more pixels, i.e. a pixel or cluster of pixels); (ii) calculating (theoretical) (color) values for at least one of the one or more colors (based on a linear relationship) (and/or one or more pixels); (iii) comparing measured and corresponding calculated values; (iv) detecting (per color and for at least one color) a deviation in the measured values due to non-linearities (caused by the pixel drivers), and determining this deviation as the non-linear pixel driver compensation. The values refer to the color space or linear space, defined by 3 coordinates (x, y, Y) or (X, Y, Z). Generally, and preferably, the processing system will be internal to the display.

However, it may be possible, technically, to have a processing system outside or external to the display. In general, one pixel driver can be used for a cluster of pixels, for example a multiple of 16, e.g. 64 or 256 pixels (per cluster).

According to an embodiment, the light-emitting display is characterized by at least three (primary) colors.

Determining the non-linear display pixel driver compensation (and therefore all steps that are part of, or involved in, it) can be performed for each display pixel or cluster of display pixels.

According to an embodiment, prior to all steps (i) to (iv), calibration is performed by means of the following steps: (a) reading, loading or entering the (native) (color) values (in 3-coordinate display ) measured (which you could interpret here as a pre-calibration measurement, i.e. a measurement before the calibration calculations or operations take place) (with a spectrometer) for the one or more colors of (each of the pixels of) the display; (b) reading, loading or entering the target values (as perceived by a human eye and/or a camera recording the display output) for one or more colors of (each of the pixels of) the display; and (c) for the one or more colors, calculating (via matrix operations) corresponding calibration matrices based on the measured and target values (in particular based on the difference between them). Taking this calibration into account, and referring back to the 'determination' method itself, when step (ii) of calculating (theoretical) (color) values is now performed, the calibration matrices can be used. The calibration matrices can be based on display content context and/or display arrangements, as known in content-dependent calibration (see for example previous patent applications WO2019/215219 A1 and US2020/0286424 mentioned above, by the same Applicant).

15 BE2022/5881

According to a second aspect of the invention, there is provided a method of implementing non-linear display pixel driver compensation performed by a processing system of (or for) a light-emitting display characterized by one or more colors, wherein said light-emitting emissive display includes pixels controlled by pixel drivers. The 'implementation' method includes the following steps: (i) determining the non-linear display pixel driver compensation based on the method of the first aspect, or reading, loading or inputting the non-linear display pixel driver compensation, determined based on the method of the first aspect, and (ii) compensating (or correcting) the deviation determined as the non-linear display pixel driver compensation.

According to an embodiment, said compensation is based on the brightness (Y value of color space coordinates) defined by a mathematical formula.

According to an embodiment, said compensation is based on the use of one or more lookup tables (data from which is stored in (non-volatile) memory), in particular on what is stored in (or represented by) the one or more lookup tables, each existing from input values and corresponding output values, taking into account the non-linearities. In addition, said compensation can be based on what is stored in multiple (i.e. at least two) lookup tables with reduced bit representation (to reduce the amount of memory required), in particular said compensation is defined based on interpolation calculations performed among them.

According to one embodiment, the compensation is performed for each display pixel or cluster of display pixels.

According to a third aspect of the invention, a method of displaying an image on a light-emitting display with non-linear display pixel driver compensation is provided. The 'display' method includes the following steps: (i) determining the non-linear display pixel driver compensation based on the method of the first aspect, or reading, loading or entering the non-linear display pixel driver compensation, determined based on the method of the first aspect; (ii) implementing the non-linear display pixel driver compensation based on the method of the second aspect; and (iii) displaying the image.

16 BE2022/5881

According to one embodiment, an additional temperature correction is applied to further improve the display of the image.

According to a fourth aspect of the invention, a system is provided for a light-emitting display, in particular for controlling light-emitting elements or pixels thereof. The system may be part of the light-emitting display, may be built-in or attached to it. The system includes an input protocol for receiving (displaying) (video) input and a PWM generating module for converting said input into signals supplied to pixel drivers (e.g. one or more), where the light-emitting elements or pixels are defined and controlled in the light output to be transmitted (and displayed in the form of video) by them. The system also includes a (supplementary) module for defining and implementing non-linear display pixel driver compensation (due to non- linearities caused by the pixel drivers) according to the method of the first and second aspects respectively.

According to an embodiment, the system further comprises a module for performing calibration (for example as referred to in an embodiment of the method of the first aspect) and thereby determining calibration matrices to be used in (ultimately) defining the output to be are emitted by the light-emitting elements or pixels (of the display).

According to an embodiment, said compensation of the method of the second aspect, for implementing non-linear display pixel driver compensation, is based in particular on the use of one or more lookup tables and the data for this one or more lookup tables is stored in and thus are retrieved from a non-volatile memory of the processing system. In addition, the one or more lookup tables herein each include input values and corresponding output values that take into account the non-linearities to be included in the signals for the pixel drivers.

Overview of the drawings

17 BE2022/5881

Figure 1 illustrates an embodiment of the traditional calibration video pipeline in accordance with the technique, showing a flow for determining the color output Rout, Gout, Bout for the primary colors RGB based on the calibration matrix (A), if determined, and on the color input Rin, Gin, Bin for the primary colors RGB as received.

Figure 2 illustrates a video pipeline embodiment in accordance with the technique, showing a scheme that can be followed for the calculation of color output Rout, Gout,

Bolt based on the calibration matrix (A) and the color input Rin, Gin, Bin as received.

Figure 3 illustrates a representation of the color Blue, comparing color coordinates, which either have the same brightness (and the same color) and are perceived in the same way (BO and B3), or else have different brightness (although the same color) and otherwise are observed (B1 and B2).

Figure 4 illustrates a video pipeline embodiment in accordance with the technique, showing a flow for determining the color output Rout, Gout, Bout for the primary colors RGB based on the calibration defined by 2 matrices Matrix1, Matrix2 and on the color input Rin, Gin , Bin for the primary colors RGB as received.

Figure 5 illustrates examples of possible Factors that can be used as weights in combination with RGB colors to determine the (final) calibration.

Figure 6 illustrates graphical representation of the non-linear red channel output measured on a display, including comparison with the linear theoretical expectation, in accordance with the invention.

Figure 7 illustrates a video pipeline embodiment in accordance with the invention, showing a flow for determining the color output Rout, Gout, Bout for the primary colors RGB, where near the end or output compensation blocks Comp R, Comp G, Comp

B are provided.

Figure 8 illustrates an exemplary embodiment showing a block diagram or flowchart for the implementation of the non-linear (sub-delta) compensation, particularly here for the red light output, in accordance with the invention.

Figure 9 illustrates an example of an LED with intelligent control, here using the

LC8823-5050 RGB SMD LED Datasheet.

Figure 10 illustrates the electronic diagram of Texas Instruments' TLC59731, which is a 3-channel, 8-bit, PWM LED driver with Single-Wire Interface.

18 BE2022/5881

Figure 11 illustrates the block diagram of MBI5759 from Macroblock, being an advanced one

LED driver built by 48 constant current source output channels and 32 switches packed into a compact BGA package.

Figure 12 illustrates an embodiment and thus a general main diagram of an oversimplified block diagram applicable to all existing (integrated or not)

LED drivers, in accordance with technology.

Figure 13 illustrates an embodiment of a block diagram for a pixel driver, in accordance with the invention.

Figure 14 shows an example embodiment of a curve exhibiting an RC effect.

Figure 15 illustrates a schematic embodiment of a method for determining non-linear display pixel driver compensation performed by a light emitting display processing system, in accordance with the invention.

Figure 16 illustrates another schematic embodiment of the method for determining non-linear display pixel driver compensation performed by a light-emitting display processing system, including initial calibration, in accordance with the invention.

Figure 17 illustrates a schematic embodiment of a method for implementing non-linear display pixel driver compensation performed by a light emitting display processing system, in accordance with the invention.

Figure 18 illustrates a schematic embodiment of a method for displaying an image on a light-emitting display with non-linear display pixel driver compensation, in accordance with the invention.

Figure 19 illustrates an embodiment of the processing system of a light-emitting display, which includes non-linear display pixel driver compensation, in accordance with the invention.

Figure 20 illustrates another video pipeline embodiment, in accordance with the invention.

Description of the invention

For a detailed description of the present invention, which continues below, reference may be made to a previous application by the same Applicant, including, for example,

19 BE2022/5881 wO2019/215219 A1, entitled "STANDALONE LIGHT-EMITTING ELEMENT DISPLAY TILE AND

METHOD" and published on November 14, 2019, and US2020/0286424, entitled "REAL-TIME

DEFORMABLE AND TRANSPARENT DISPLAY" and published on September 10, 2020. Where it appears relevant to any aspect of the present invention, such reference will be made specifically and explicitly below.

Problem

When applying the calibration principle as described previously (in detailed background description), measurement of the end result of e.g. Rtarg, Gtarg, Btarg and/or

Wtarg (but also other calculated output values) see that there is a deviation from what is measured and what is really desired. This means that e.g. Rtarg-measured # Rtarg-calculated. This is due to non-linearities of the system in the display after the PWM generation via the constant current driver to the LEDs.

Assuming the PWM is calculated perfectly, this means that non-linearities have been introduced. Figure 6 illustrates such non-linearities, in particular Figure 6 (a) shows a graph of e.g. a non-linearity measured on Red color in a display. On the horizontal x-axis in this graph we have shown the bit number (here 16-bit) for Red, which is used as input to the constant current driver (or pixel driver in general). This bit number is also known as PWM number. On the vertical y-axis of the graph, the Red brightness light output is shown in nit (= candela per m2). The dots show the actual measurement (including non-linearities), while the solid line is the linear (theoretical and expected) case. Figure 6(b) shows the deviation of the 'Red Light Output' compared to the linear case.

Proposed solution

According to the above, an additional calculation step for these nonlinearities must be implemented.

A possible solution could be to define 3 factors and add multiple matrices to apply and respond to them. A disadvantage of this solution is that it increases the digital implementation complexity (latency and speed) for full recomputation

20 BE2022/5881 enlarged. The factors then determine the amount or weight to take, e.g. multiple matrices defined in XYZ (linear) space.

The number of matrices and/or matrix elements can be chosen arbitrarily, depending on the accuracy required and the factors subsequently needed to determine which matrices to interpolate from. All these calculations must be done in addition to the visual perception improvement described earlier, should one require it.

Another disadvantage is the amount of memory and fetch operations required to compute one pixel. This also has a disadvantage for the system performance in the event that many pixels have to be processed.

A simplification could be to assume that the color (x,y) coordinates do not change (too much) due to these non-linearities. In that case we only need to do something about the Y value of the real primary color. The complete pipeline then looks as in Figure 7, which partly represents the flow of previously discussed Figure 4, for the determination of the color output Rout, Gout, Bout for the primary colors RGB based on the calibration defined by 2 matrices Matrix1, Matrix2 and on the color input Rin, Gin, Bin for the primary colors RGB as received. For simplicity in the diagram, here in Figure 7 are the

DDR (memory) access lines omitted. An extra step or calculation is provided near the output of the diagram by means of compensation blocks Comp R, Comp G, Comp B.

At this point we added 3 compensation blocks Comp R, Comp G, Comp B which work on all individual primary RGB colors respectively. There are several ways to implement the compensation blocks.

A. Mathematical formula approach o Y = ax” +bx"7} + cx" 24+ where n should be set to an integer to best fit the final curve.

B. Lookup table approach o We define a lookup table with input values and output values.

In reality (digital world}, if we assume that the PWM values are calculated in 16 bit, it means that we have to create a 65536 long RAM lookup table with 16 bit output. E.g. on

21 BE2022/5881 location 32768 the output value is 30000 (instead of 32768 which is the linear case).

C. Sub-delta implementation o This implementation is drawn as a block diagram in Figure 8, an example embodiment of a flowchart for the implementation of the sub-delta compensation, especially here for the Red Light output.

Both the A and B approaches require significant hardware resources, being either a computation pipeline or significantly large memory. The following implementation C, also called sub-delta, is an approach that is limited in compute and RAM resources and can be performed with only a few clocks of latency.

As mentioned, the example diagram of Figure 8 is shown for the Red channel, but applies to all colors. The flow and therefore the sequence of calculations illustrated in this diagram is now discussed further.

Suppose a digital bitstream of R (Red channel) values of 16 bit: Rin (15 to 0), with 16 parallel bit paths, and n=15. We split this R channel into 2 parts: a top-bit channel Rt from n to a, where a=4 here as an example. So we get a top-bit channel Rt of 12 bits, i.e. Rt (15 to 4), and a bottom-bit channel of 4 bits, i.e. Rb (3 to 0). So in this example, the upper part Rt has a width of 12 bits (values between 0 and 4095, or a total of 4096 = 22 values) and the lower part Rb has a width of 4 bits (values between 0 and 15, or a total of 16 = 2% values). While Rt is defined from "n to a" bits, and Rb includes "a" bits (0 is included), Rin can be defined as Rt x 2° + Rb.

As shown in the diagram of Figure 8, the top-bit channel Rt comes in 2 lookup tables (lut): 4096-word Toplut and 4096-word Bottomlut. Each word is e.g. 12 bit signed.

So we now have 2 lookup tables of 4096 x 12 bits each, which is significantly less than the 65536 x 16 values suggested in solution B above. Thus, using two or more lookup tables with reduced bit representation (rather than using only one) reduces space requirements and avoids heavy processing (with large numbers). Another way to save (memory) space and processing time

22 BE2022/5881, is to work (in the calculations) mainly with the deviation of the non-linear versus the linear case (or the difference between them), instead of using the absolute numbers of linear output and non-linearities that make this difference.

It is noted that these 2 lookup tables (Toplut and Bottomlut) can be used to make an interpolation between the values in their respective and corresponding locations determined by the Rt value. In addition, the Rb value can be used to determine such an interpolation, because the Rb value can be used to interpolate between a value from the Toplut (i.e. at a certain location thereof) and a value from the

Bottomlut (in corresponding location thereof) .

Assume that for the Red channel e.g. Rb = 10 and Rt = 1500 as an example. We assume that R Toplut at address 1500 (Rt) has value 2900 and R Bottomlut at corresponding location 1500 (Rt) has value 2800. Both values appear at the output of the lookup tables when addressed with Rt = 1500, being 2900 and 2800 respectively. As shown in the diagram of Figure 8, the R Toplut value (here e.g. 2900) is then multiplied by the Rb value (with 2° = 2* possibilities in total) and the R Bottomlut value (here e.g. 2800) is multiplied by (2% — Rb) = 2% — 10 =16 — 10 = 6.

At this point we end up with: (2900 x 10 + 2800 x 6) which is then divided by (2% = 16) for normalization purposes as part of the interpolation. The formula becomes: (2900 x 10 + 2800 x 6) / 16, which we call a delta value, to be added to the original color value to compensate for the non-linearities.

Finally, for the output Rout, we add this delta value to the original input value Rin, which is Rt x 2% + Rb. Consequently, the output value Rout becomes:

Rout = Rin + Toplut(Rt) * Rb + Room * (2% — Rp)

Rin = Rt * 2% + Rb

As a result, Rout = (1500 * 16 + 10) + (2900 * 10 + 2800 * 6)/16 = 24010 + 2862 = 26872.

23 BE2022/5881

The 2862 is the delta and is also the 2nd compensation on the color, and is therefore called sub-delta.

In the case where all individual LED primaries exhibit the same behavior, only 3 sets of lookup tables need to be created where each individual LED calculation goes through the same table. It is noted that - in the case where the compensation needs to be different - sets of look-up tables for calculations can be created and selected according to the LED that needs a certain compensation.

FPGA implementation

All of the above video pipelines can be implemented in an FPGA (Field

Programmable Gate Array) or standard ASIC. However, when the number of pixels has to be calculated with calibration and/or the subdelta correction, this requires a lot of memory access per pixel, especially for the calibration part. In the case of using the visual perception calibration, for example, this means that for each RGB pixel to be calculated, at least 18 values (2 matrices of 9 values) must be retrieved from a pre-computed location in memory. Although this can be implemented, it has a disadvantage in terms of computation speeds and/or limitation of the number of pixels. To reduce FPGA or ASIC complexity, some of the computation and nonlinearity compensation can be done more locally at the LED level or around clusters of multiple LEDs, as described in the next section.

Chip implementation

Single-pixel LEDs with PWM generation have been around for a long time. Examples of this are e.g.

LC8823 LEDs. These are called LEDs with intelligent control. Instead of just having anode and cathode for the LEDs, they have digital inputs and outputs as seen in

Figure 9, illustrating by way of example LC8823-5050 RGB SMD LED Datasheet. Until now, these inputs are only used to input the digital PWM value, which is then used internally to generate some PWM that drives the internal constant current sources to light the LEDs.

24 BE2022/5881

However, it is part of the invention to also apply the calibration and/or subdelta correction as a local solution by means of chip implementation (for example LED chip or driver chip). This can be either A, the mathematical approach where all factors are determined by a protocol to fill in the values, or B, a total lookup table for each color, where the lookup table is also loaded by the input protocol. Solution C can also be implemented in exactly the same way as described previously, for example acting on the individual LED.

In general, the invention of adding a lookup table for (brightness and/or color) compensation in this kind of LEDs is considered inventive and novel to solve all the above problems, such as for example sequential processing which is more time consuming (and possibly requires more resources) than currently distributed and/or parallel processing (e.g. local) in accordance with the invention. Moving on, adding complexity closer to the LEDs reduces the complexity (and size) of control for an LED display.

Now the LED does not necessarily have to be in the same package. Constant current drivers (common cathode or common anode) are readily available, such as e.g. TLC59731, a 3-channel 8-bit

PWM driver with a single wire interface, where the out0, out1 and out2 and 3 pins must be connected to the LEDs as shown in Figure 10, illustrating by way of example

TLC59731 electronic diagram of the Texas Instruments (TI) 3-channel, 8-bit, PWM LED driver with Single-Wire Interface.

And there are more complex constant current drivers that can address multiple arrays of LEDs. Example here is e.g. MBI5759 from Macroblock, i.e. an advanced LED driver built with 48 constant current source output channels and 32 switches packed into a compact BGA package. The block diagram of this (proprietary) 48-channel PWM constant current LED source driver with embedded switch for 1:32 time multiplex applications is shown in Figure 11. As one can see, there is memory (SRAM) in these drivers (to control the LED

PWM values), but no memory was ever provided to store individual LED calibration data or non-linearity corrections in these types of chips.

25 BE2022/5881

Oversimplified, the block diagrams resemble all existing (integrated or non-integrated) LED drivers, as illustrated in Figure 12, which shows the general principle diagram. The input protocol is fed to the PWM generator, which drives the LED.

Apart from the general methods previously described, it is part of the invention to add functionality blocks to the constant current driver chipsets with or without integrated LEDs, as illustrated in Figure 13, again repeating the general principle diagram of Figure 12 shown, but now with additional blocks (with dotted canvas) provided. A schematic embodiment is shown of the system 80 for a light-emitting display 10, in particular for driving light-emitting elements or pixels 40 thereof, with non-linear display pixel driver compensation. The system 80 includes an input protocol 81 for receiving (display) (video) input and a

PWM generating module 84 for converting said input into signals to be supplied to pixel drivers 45, defining and controlling the light-emitting elements or pixels 40 in the images to be transmitted by them (and displayed in the form of video) (light) output. The system 80 also includes an additional module 83 for determining and/or implementing non-linear display pixel driver compensation (due to non-linearities caused by the pixel drivers). The system 80 may further include a module 82 for (pre)performing calibration and determining calibration matrices to be used in defining the final output to be emitted by the light-emitting elements or pixels 40.

Referring further to Figure 13, at the input of the system 80, video input is received 131 and input via the input protocol 81, from which e.g. RGB data (16-bit) is supplied 132. This RGB data can then be calibrated via the module 82, which now outputs calibrated RGB data 133. The calibrated RGB data can then be used as input for the non- linear compensation 83, from which comes 134 compensated (and previously) calibrated data. The compensated calibrated data can now be fed to the PWM generator 84, to generate and supply 135 appropriate PWM signals via the pixel drivers 45 to the LEDs or pixels 40 and use this to switch it on or off.

26 BE2022/5881

For the additional blocks 82, 83 it may be (as shown here) that multiple layers (or versions or phases) are provided for the calibration 82 and for the non-linear compensation 83 (also called subdelta) respectively. Such multiple layers may need to be applied due to multiple colors and/or multiple types of LEDs for the calibration and/or non-linear compensation to be performed. It is noted that for each type or set of colors, multiple instances can be added depending on the complexity to be solved. In general one can say that every individual

RGB pixel needs at least one set of calibration data (9 values). In the case of visual perception improvement, a set of 18 values is needed and in the case of additional temperature compensation, a set of 3 additional values for each color is needed. If all individual colors R, G, B (or others) have the same non-linearity behavior, at least 3 non-linearity compensation blocks must be added.

Reason for non-linearities

There can be several reasons for non-linearities. Some reasons (but not limited to all reasons) are: 1. Layout capacity of an LED board; 2. Temperature behavior of the constant current drivers; 3. Speed of switching the constant current drivers on/off; and 4. DI/DV (voltage and load dependence of the constant current drivers).

Figure 14 shows an example embodiment of a curve 140 exhibiting an RC effect.

The area under the curve peaks is the energy for lighting the LEDs and depending on the PWM width this energy varies.

It is known from the industry that perfect constant current drivers do not exist. Most of these depend on the current required and also on the supply voltage and can be found in the datasheets.

Sample extract of constant current driver (MBI5759 from Macroblock) datasheet: e Constant output current range: o -0.5-15mMA @ Voo = Vives = 3.8V, Vieor = 2.8V supply voltage e Excellent output current accuracy:

27 BE2022/5881 o Between channels: <+ 2.5% (Max) o Between ICs: < + 3.0% (Max)

Figure 15 illustrates a schematic embodiment of the method 300 for determining non-linear display pixel driver compensation 30 performed by a processing system 20 of a light-emitting display 10 characterized by one or more colors 15, for example three primary colors red, green and blue (RGB). The light emitting display 10 includes pixels 40 controlled by pixel drivers 45. The method 300 includes several steps, shown here as four in total. In a first step (i), values 31 are measured 301 for one or more colors 15 and/or for one or more pixels 40 of the display 10. Such values 31 can also be referred to as color values, and are e.g. measured on the display and taken in real time. The color measurement for achieving measured values 31 can be e.g. with a spectrometer. The values 31 can be represented in color space or linear space, defined by 3 coordinates (x, y, Y) or (X, Y, Z) respectively. In a second step (ii), the theoretical color values 32 are calculated 302 for the one or more colors 15 and/or for the one or more pixels 40 of the display 10, while such a calculation is based on a linear relationship. In a third step (iii) the measured and corresponding calculated values 31, 32 are compared 303. In a fourth step (iv) a deviation in the measured values 31 (compared to the calculated values 32) is observed 304, e.g. per color and for at least one color, due to non-linearities, in particular caused by the pixel drivers 45, and the deviation is determined 305 as the non-linear pixel driver compensation 30.

As depicted in Figure 16, the method 300 may initially include a calibration portion 500. The initial calibration 500, performed prior to four steps (i) to (iv) described above, includes three steps (a) to (c). A first step (a) comprises reading, loading or inputting 501 the so-called original color values 51 (in 3-coordinate representation) measured, e.g. with a spectrometer, for the one or more colors 15 of (each of the pixels 40 of) the display 10. A second step (b) involves reading, loading or inputting 502 the target values 52 (as perceived by a human eye and/ or a camera recording the display output) for the one or more colors 15 of (each of the pixels 40 of) display 10. A third step (c) involves calculating 503 (via matrix operations), for the one or more colors 15 , associated calibration matrices 50 based on the measured and target values 51, 52, in particular based on the difference between them. Referring back to method 300, now

28 BE2022/5881 when calculating 302 the theoretical color values 32 in step (ii), the calibration matrices 50 as calculated by the method 500 are used as indicated by the dashed line arrow.

Figure 17 illustrates a schematic embodiment of the method 600 for implementing non-linear display pixel driver compensation 30 performed by a processing system 20 of a light-emitting display 10 characterized by one or more colors 15, for example three primary colors red, green and blue (RGB). The light-emitting display 10 includes pixels 40 that are controlled by pixel drivers 45. The method 600 includes several steps. In a first step (i), the non-linear display pixel driver compensation 30 is determined 601 on the basis of the method 300, or the non-linear display pixel driver compensation 30 determined on the basis of the method 300 is read, loaded or input 602 A second step (ii) involves compensating 603 for the deviation determined as the non-linear pixel driver compensation 30.

The compensation 603 may be based on the brightness (Y value of color space coordinates) defined by a mathematical formula, as indicated by the module 63.

The compensation 603 may be based on the use of one or more lookup tables (data of which are stored in (non-volatile) memory) as indicated by the module 64, in particular on what is stored in the one or more lookup tables, each consisting of input values and corresponding output values, taking into account the non-linearities.

In addition, the offset 603 can be based on what is stored in multiple lookup tables with a reduced bit representation (to reduce the amount of memory required), in particular the offset 603 can be defined based on interpolation calculations indicated by the module 65, performed under this.

Figure 18 illustrates a schematic embodiment of the method for displaying an image 70 on a light-emitting display 10 with non-linear display pixel driver compensation. The method may initially consist of a calibration part 500, although this is not strictly necessary, as indicated by the dotted canvas of this block 500. The method includes determining the non-linear display pixel driver compensation based on method 300, or reading , loading or entering the non-linear display pixel driver compensation, determined based on method 300 (hence indicated by block 300), and

29 BE2022/5881 then implementing the non-linear display pixel driver compensation based on method 600 (hence indicated by block 600). The method then includes displaying 700 the image 70 on the display 10 (as indicated by block 700).

According to an embodiment, the method may include an additional temperature correction (not shown).

Figure 19 illustrates an embodiment of the processing system of a light-emitting display, which includes non-linear display pixel driver compensation, in accordance with the invention. Figure 19 (a) and (b) shows an embodiment of a so-called receiver card 190 (or processing system) that can be mounted in or on a display tile. In particular, Figure 19 (a) shows one side (or front) of the receiver card 190, while Figure 19 (b) illustrates the other side (or rear) of this card 190.

Referring back to Figure 19(a), the video input 191 and video output 192 ports are shown here, for inputting and outputting the video stream, or in other words, for receiving the video input 191 and outputting it respectively. transmitting the video output 192. Furthermore, an FPGA 193 (with processor) and a non-volatile memory 194 are shown on this side of the card 190. For example, non-volatile memory 194 contains or stores data necessary to format or populate the lookup table(s). This data can e.g. be entered after measurements and calculations of the non-linearities have been carried out. The other side of the receiver card 190 in Figure 19(b) illustrates an interface connection 195 represented by two bar-shaped connectors, as well as volatile memory 196, which can be used, for example, to store calibration matrices. The interface connection 195 can be coupled or connected to a connection 199 on an LED board 197, an example embodiment of which is schematically shown in Figure 19(c).

The LED board 197 includes a number of constant current drivers 198, all of which are connected to the terminal 199. As we know, a constant current driver 199 can be used to control a pixel or LED, or a number of them. It is common for one constant current driver 199 to control a cluster of pixels or LEDs, e.g. a multiple of 16, for example 64 or 256.

Figure 20 illustrates another video pipeline embodiment, in accordance with the invention. The video 200 signal comes in as received by the display system (and its processing), and a position or window 201 is defined and stored. Thereafter

30 BE2022/5881, each color of a pixel goes through a gamma (or y) correction 202, followed by calibration 203.

Furthermore, the sub-delta (or subA) compensation 204 is performed, for example a look-up table is created (by means of input received from the processor) and then the sub-delta is determined. Then, as indicated by block 205, RGB is processed and signals are sent to the constant current drivers 206 (depending e.g. on type of constant current driver (ccd), number of pixels or LEDs, type of board etc.), ultimately leading to the light output 207 (in the form of a video image) which is emitted by the LEDs or pixels, controlled by the constant current driver(s). It is noted that VHDL can be used as a programming language, or alternatively Verilog also applies.

Word list

Figure 5

B only = b only

Figure 6

Red non-linearity = red non-linearity

Red Corr formula = red corr formula

Series = Series

Linear = linear

Figure 9

Symbol = symbol

Pin Name = pin name

Function description = job description

Data Input = data input

CLK Input = CLK input

Ground, grounding = earthing

Power = power supply

CLK output = CLK output

Control signal Input data = control signal input data

Control signal Input Clock data = control signal input clock data

The signal and power supply and grounding

Power supply pin = power supply pin

31 BE2022/5881

Control signal output clock data = control signal output clock data

Control signal output data = control signal output data

Figure 10

Shunt Regulator = shunt regulator

Pulse Generator = pulse generator

Reset = reset

Outen = out

Interface Control = interface control 32-Bit shift register = 32-Bit shift register

Upper = topmost

Lower = bottom

Command Decoder = command decoder 24-Bit Data Latch = 24-Bit data latch

Internal Oscillator = internal oscillator

GS Clock Counter = GS clock counter 8-Bit PWM Timing Control with Simple Gamma Correction = 8-Bit PWM timing control with simple gamma correction

Switching Delay = switch delay 3-Channel Sink Driver = 3-channel sink driver

Figure 11

VGEN with individual current gain control = VGEN with individual current gain control

Digital Regulator = digital controller

Power saving = power saving

Voltage Reference = voltage reference

Deghost = to despiritualize

Bit count control = control of the number of bits

Control and Synchronization = control and synchronization

Configuration Register = configuration register

Scan Control = scan control 48bit ping pong SRAM support = 48-Bit ping pong SRAM support

R/G/B comparator = R/G/B comparator

32 BE2022/5881

Output Buffer = output buffer 48ch Constant Current Source = 48ch constant current source 16bit shift register (FIFO) = 16-Bit shift register (FIFO) 48bit Error Status = 48-Bit error status

Error Detection = error detection

Bi-direction Control = bi-directional control

Figure 14

Voltage = voltage

Time constant = time constant

Figure 20 output = output

Claims (15)

33 BE2022/5881 Conclusions A method (300) for determining non-linear display pixel driver compensation (30) performed by a processing system (20) of a light-emitting display (10) characterized by one or more colors (15), wherein the light-emitting emissive display (10) comprises pixels (40) controlled by pixel drivers (45) which cause non-linearities, the method (300) comprising: (i) measuring (301) values (31) for at least one of the one or more colors; (ii) calculating (302) values (32) for the at least one of the one or more colors; (iii) comparing (303) measured and corresponding calculated values; (iv) detecting (304) a deviation in the measured values due to the non-linearities, and determining (305) said deviation as the non-linear pixel driver compensation (30). The method (300) of claim 1, wherein prior to all steps (i) to (iv), calibration (500) is performed by (a) reading, loading or entering (501) the values (51 ) measured for the one or more colors of the display (10); (b) reading, loading or inputting (502) the target values (52) for the one or more colors of the display (10); and (c) for the one or more colors, calculating (503) corresponding calibration matrices (50) based on the measured and target values (51, 52); and when calculating values (32) in step (ii), use the calibration matrices (50). The method (300) of claim 2, wherein the calibration matrices (50) are based on display content context and/or display settings. The method (300) according to claims 1 to 3, wherein the light-emitting display (10) is characterized by at least three colors. The method (300) according to claims 1 to 4, wherein the determination is performed for each display pixel or cluster of display pixels. 6. A method (600) for implementing non-linear display pixel driver compensation (30) performed by a processing system (20) of a light-emitting display (10) characterized by one or more colors (15), wherein the light - emissive display (10) comprising pixels (40) controlled by pixel drivers (45) causing non-linearities, the method (600) comprising: (i) determining (601) the 34 BE2022/5881 non-linear display pixel driver compensation (30) based on the method (300) of claims 1 to 5, or reading, loading or inputting (602) the non-linear display pixel driver compensation (30), determined based on the method (300) of claims 1 to 5, and (ii) compensating (603) for said deviation determined as the non-linear pixel driver compensation (30). The method of claim 6, wherein the compensation (603) is based on the brightness defined by a mathematical formula. The method of claim 6, wherein the compensating (603) is based on the use of one or more lookup tables, in particular on what is stored in the one or more lookup tables, each consisting of input values and corresponding output values taking into account with the non-linearities. The method of claim 8, wherein the compensation (603) is based on what is stored in a number of reduced bit representation lookup tables, in particular the compensation is defined from interpolation calculations performed between them. The method of claim 6 to 9, wherein the compensating (603) is performed for each display pixel or cluster of display pixels. 11. A method of displaying an image (70) on a light-emitting display (10) with non-linear display pixel driver compensation (30), comprising: (i) determining the non-linear display pixel driver compensation (30 ) based on the method (300) of claims 1 to 5, or reading, loading or inputting the non-linear display pixel driver compensation (30) determined based on the method (300) of claims 1 to 5; (ii) implementing the non-linear display pixel driver compensation (30) based on the method (600) of claims 6 to 10; and (iii) displaying (700) the image (70) on the display (10). The method according to claim 11, wherein an additional temperature correction is applied. 35 BE2022/5881 13. A system (80) for a light-emitting display (10), in particular for driving light-emitting elements or pixels (40) thereof, comprising an input protocol (81) for receiving input and a PWM generating module (84) for converting said input into signals to be supplied to pixel drivers (45) causing non-linearities, defining the light-emitting elements or pixels (40) in the output to be emitted by them and controlled, characterized in that said system (80) comprises a module (83) for determining and implementing non-linear display pixel driver compensation (30) according to the method (300, 600) of claims 1 to 5 and claim 6 to respectively 10. The system (80) of claim 13, further comprising a module (82) for performing calibration (500) and determining calibration matrices (50) to be used in defining the output to be emitted by the light -emitting elements or pixels (40). The system (80) of claim 13, wherein the compensating method (600) for implementing non-linear display pixel driver compensation (30) is specifically based on the use of one or more lookup tables and on the data for said one or more lookup tables is stored in and thus must be retrieved from a non-volatile memory of the processing system (20), wherein the one or more lookup tables each consist of input values and corresponding output values, which take into account the non- linearities to be included in the signals for the pixel drivers (45).