Device and method for applying a look-up table

Abstract

A device applies a pre - function w = P(x) to an input signal x to obtain a first result w, and applies a LUT to the first result w, where the LUT represents a main function f w (w) defined for a second grid Gw of values, such that the pre - function P(x) is defined piece - wise on a first grid Gx of signal values, where Gw = P(Gx). The device can also obtain the pre - function P(x) defined piece - wise on the first grid Gx of the signal x, and calculate the LUT using the second grid Gw = P(Gx). A piece - wise pre - function P(x) can be obtained from a second pre - function Q(x) by applying Q(x) to the signal values x to calculate a second grid Gw = Q(Gx), and defining the pre - function P(x) piece - wise on the first grid Gx by linear interpolation of the values of the second grid Gw such that P(Gx)=Q(Gx). w (w), such that the pre - function P(x) is defined piece - wise on a first grid Gx of signal values, where Gw = P(Gx). The device can also obtain the pre - function P(x) defined piece - wise on the first grid Gx of the signal x, and calculate the LUT using the second grid Gw = P(Gx). A piece - wise pre - function P(x) can be obtained from a second pre - function Q(x) by applying Q(x) to the signal values x to calculate a second grid Gw = Q(Gx), and defining the pre - function P(x) piece - wise on the first grid Gx by linear interpolation of the values of the second grid Gw such that P(Gx)=Q(Gx).

Description

Technical Field

[0001] The present disclosure generally relates to signal processing, and more particularly to signal processing using a look-up table (LUT). Background Art

[0002] This section is intended to introduce the reader to various aspects of the art that may be related to various aspects of the present disclosure described and / or claimed below. This discussion is considered to be helpful in providing background information to the reader to facilitate a better understanding of the various aspects of the present disclosure. Accordingly, it should be understood that these statements are to be read in this light and not as an admission of prior art.

[0003] It is well known to apply a look-up table (LUT) calculated according to a second main function f(x) to an input signal x rather than applying the second main function itself, for example to accelerate processing. The LUT is typically generated by regular sampling of the second main function.

[0004] As an illustrative example, the second main function is the exponential function f(x) = (10 x -1) / 9, for a one-dimensional signal x in the range [0; 1]. In this example, assume that the LUT is a one-dimensional regular LUT of size 3 with a LUT input grid {0; 0.5; 1}. The LUT entries are {f(0); f(0.5); f(1)} = {0; (10 0.5 -1) / 9; 1} = {0; 0.24; 1}

[0005] Those skilled in the art will understand that these principles apply to other signals, such as audio signals and video signals, for example two-dimensional chrominance signals, three-dimensional color coordinates or n-dimensional signals in an n-dimensional signal space. These principles also apply to, for example, an irregular LUT with a LUT entry grid {0; 0.4; 1} and irregular intervals of 0.4 and 0.6 respectively.

[0006] Since LUTs typically have a finite size, in such cases, applying them to signals usually requires interpolation. Some interpolation methods were reviewed by Vandenbberg and Andriani in their paper titled "A Survey on 3D-LUT Performance in 10-bit and 12-bit HDR BT.2100PQ" published at SMPTE in 2018.

[0007] Generally, to perform interpolation, in the first step, the input signal is interpolated from the LUT input grid. Linear interpolation is commonly applied, but the same principle applies to non-linear interpolation. In the above example, if the input signal is x = 0.2, linear interpolation can use the first two grid values, resulting in the following interpolation: x = 0.2 = c10 + c20.5, where 0 and 0.5 are the first two values of the LUT input grid, and c1 = 0.6; c2 = 0.4 are the linear interpolation coefficients. In the second step, the output signal LUT(x) is interpolated from the LUT entries. Usually, the same interpolation method as in the first step is used. In this example, linear interpolation is used in the first step. Assuming linear interpolation is also used in the second step and usually the same interpolation coefficients are used, this gives the output signal LUT(x) = c10 + c20.24. However, other coefficients and other interpolation methods can be used to derive LUT(x) from the LUT entries.

[0008] If the second principal function is non-linear and the interpolation of the LUT entries is linear, the effect of applying the LUT is similar to piecewise interpolation of the second principal function. If the second principal function f(x) is sampled and stored in the LUT, applying the LUT to the signal x using linear interpolation can be written as the LUT application function LUT(x) = PL x (f(x)), where PL x is piecewise linearized on the grid of signal values x. For example, if the LUT is three-dimensional, well-known piecewise interpolation methods include trilinear, triangular prism, and tetrahedral interpolation.

[0009] It is also well known to apply a pre - function to a signal before applying the LUT. The pre - function is typically a monotonically increasing function. The pre - function itself can be applied using a look - up table, which is hereinafter referred to as the pre - LUT. The pre - function is typically one - dimensional. If the LUT is multi - dimensional, a one - dimensional pre - function can be applied to each signal coordinate, i.e., to each dimension. However, the pre - LUT can also be multi - dimensional. For example, in front of a three - dimensional LUT designed for a three - dimensional input signal, there can be a two - dimensional pre - LUT for two channels and a one - dimensional pre - LUT for the third channel. Additionally, not all channels can be processed using a pre - LUT or a pre - function. For example, in front of a two - dimensional LUT designed for a two - dimensional input signal, there can be a one - dimensional pre - function for the first channel, only when the second channel is directly input into the LUT. For the sake of simplicity of description, hereinafter, the case of a one - dimensional LUT and a one - dimensional pre - function is considered, but it should be understood that the principle can be extended to higher dimensions. When applying the pre - function Q(x) to a signal, the signal range of Q(x) is typically equal to the signal range of the signal x itself. For example, in the case of a one - dimensional pre - function, if the input value is in the range [0; 1], the application of the pre - function will produce a value that is also in the range [0; 1]. However, the pre - function can also include a change in range. For example, after applying the pre - function, a one - dimensional input signal in the range [0; 220] can have a range [0; 1]. Hereinafter, for simplicity, it is assumed that the pre - function preserves the signal range. However, all principles also apply to pre - functions that do not preserve the signal range.

[0010] A common reason for applying a pre - function is to reduce LUT interpolation error. In the sense of sampling theory, any interpolation applied to a LUT entry will typically produce a LUT interpolation error once the sampling of the second main function on the LUT input grid that results in the LUT entry does not fully represent the second main function. For example, if linear interpolation is used to apply the LUT to an input signal and if the second main function is non - linear, the interpolation error will cause the resulting LUT application function LUT(x) not to be equal to the second main function itself. To reduce the LUT interpolation error, multiple criteria can be used to design the pre - function.

[0011] The first criterion for designing the pre - function Q(x) is the non - linearity of the second main function itself. In this case, for the range of the input value x, the pre - function Q(x) preferably has a slope Q’(x)>1, where the second main function f(x) is steep, i.e., where |f’(x)|>1.

[0012] Another criterion for designing a pre - function is that for a specific range of input values x, compared to other ranges, the precision of the output signal is increased (in other words, the LUT interpolation error is reduced). This can be achieved by a pre - function Q(x) having a slope Q′(x)>1 for this range of input values.

[0013] Examples of well - known pre - functions are logarithmic, exponential, and sigmoid functions, but other functions can also be used.

[0014] Applying the pre - function Q(x) to the signal x results in the signal w = Q(x). After applying the pre - function, a LUT is typically applied to the signal w, resulting in LUT(w). The process of applying the pre - function and the LUT to the signal x can be represented as LUT(Q(x)). Generally, this solution replaces directly applying a given second main function f(x) to the signal, which means that preferably LUT(Q(x)) is as close as possible to f(x). If a pre - function is applied before the LUT, the pre - function must be considered within the LUT to satisfy this preference. Several known methods can be used to achieve the consideration of the pre - function within the LUT, and one of them will now be described.

[0015] An example method of considering the pre - function within the LUT and making LUT(Q(x)) close to f(x) is to invert the pre - function Q(x) within the LUT, which gives a new adapted look - up table LUT Q , such that LUT Q (w)=PL w (f(Q -1 (w)), where PL w is piece - wise linearized based on the regular sampling of w. Where w = Q(x) follows LUT Q (Q(x))=PL w (f(x)), thus being close to f(x) up to piece - wise linearization. The function f(Q -1 (w)) is called the "cascaded function" or "adapted function". It can be said that by sampling in w, the adapted look - up table LUT w can be derived from the adapted function f -1 (w)=f(Q Q (w)) in the same way as the common look - up table LUT is derived from the common second main function f(x) by sampling in x. The advantage of using a pre - function is that regular sampling is done on w = Q(x) rather than x. The interpolation errors are regularly distributed over the range of w, but irregularly over the range of x. Depending on the pre - function, the errors can be reduced in some parts of the range of x and increased in other parts. In other words, the pre - function changes the regularly sampled look - up table LUT(x) to LUT QCombination of a pre - function of (Q(x)) and an adapted look - up table, where the combination corresponds to an irregular sampling of x.

[0016] For example, if the pre - function is the logarithmic function Q(x)=log2(x + 1), then the inverse pre - function is Q (-1)(w) = 2 w −1. Then, the entries of the adapted look - up table LUT Q derived from the above example of the regular LUT are {f(Q^(−1)(0); f(Q^(−1)(0.5)); f(Q^(−1)(1))}={0; 0.41; 1}. When the LUT is applied, the first LUT entry and the second LUT entry are used to transform the input signal values in the first interval between 0 and Q -1 (0.5)=0.41, while the second LUT entry and the third LUT entry are used to transform the input signal values in the second interval between Q -1 (0.5)=0.41 and 1. The benefit of the pre - function is that the signal values in the first interval will generally have higher precision because the interval is smaller and the sampling is denser. Higher precision means a smaller LUT application error E = f(x)-LUT Q (Q(x)). This is the error introduced when representing the second main function as a concatenation of a LUT or a pre - LUT and a LUT and applying it to the input signal. More specifically, the LUT application error is the difference between the result of applying the pre - function and the LUT to the signal and the result of applying the second main function itself to the signal. Generally speaking, the reason why the LUT application error is smaller for the signal values in the first interval is that the first interval is smaller. Therefore, the LUT entry density for each signal range is higher, and the signal values are transformed with a smaller LUT application error compared to the values in the second interval.

[0017] However, due to a local mismatch between the pre - function and the interpolation method used during LUT application, the use of the pre - function as described above may lead to additional errors.

[0018] Continuing with the above example, consider the input signal values between 0 and 0.41 transformed using the first LUT entry and the second LUT entry. The pre - function ensures that x = 0 and x = 0.41 are mapped to w = 0 and w = 0.5 respectively. However, the pre - function Q(x)=log2(x + 1) is not linear in [0, 0.41]. After applying the pre - function to the signal x such that w = Q(x), since applying the LUT Q to w uses interpolation of the first LUT entry and the second LUT entry with an interpolation method independent of the pre - function, the non - linearity of the pre - function is not compensated. For example, if the interpolation method is linear, the non - linearity of the pre - function affects the resulting output signal.

[0019] In other words, the prefunction allows concentrating the LUT precision into a part of the range of the input signal and thus can enhance the precision of a part of the range of the input signal on a large scale. However, the non-linearity of the prefunction may negatively affect the precision on a micro scale between two LUT entries, especially when linear interpolation is used for LUT applications. In this way, certain non-linear prefunctions can increase the non-linearity of the LUT Q(Q(x)) and may even increase the error LUT application error E. In particular, when linear interpolation is used for applications adapting the LUT, interpolation errors may increase. If more complex interpolation methods (such as non-linear interpolation) are used, the interpolation error can be reduced compared to linear interpolation, but the non-linear prefunction can still increase the non-linearity of the process of LUT Q (Q(x)), and thus increase the LUT application error.

[0020] Therefore, it should be understood that a solution is needed to address at least some of the drawbacks associated with LUTs. The present principle provides such a solution. Summary of the Invention

[0021] In a first aspect, the principles of the present invention relate to a method that includes: applying a prefunction w = P(x) to an input signal x to obtain a first result w, and applying a LUT to the first result w, where the LUT represents a main function f w (w) defined for values of a second grid Gw, such that the prefunction P(x) is defined piecewise on a first grid Gx of signal values, where Gw = P(Gx).

[0022] In a second aspect, the principles of the present invention relate to a device that includes: a memory configured to store program code instructions executable by a processor; and at least one hardware processor configured to execute the program code instructions to apply a prefunction w = P(x) to an input signal x to obtain a first result w, and apply a LUT to the first result w, where the LUT represents a main function f w (w) defined for values of a second grid Gw, such that the prefunction P(x) is defined piecewise on a first grid Gx of signal values, where Gw = P(Gx).

[0023] In a third aspect, the principles of the present invention relate to a computer program product stored on a non-transitory computer-readable medium and including program code instructions that can be executed by a processor to implement the steps of a method according to any implementation of the first aspect. Brief Description of the Drawings

[0024] The features of the present principle will now be described by way of non-limiting examples with reference to the accompanying drawings, in which:

[0025] Figure 1 An apparatus showing an embodiment according to the principles of the present invention is shown;

[0026] Figure 2 A method showing a first embodiment according to the principles of the present invention is shown;

[0027] Figure 3 A method showing a second embodiment according to the principles of the present invention is shown;

[0028] Figure 4 A variant of the second embodiment is shown;

[0029] Figure 5 Variants of the first and second embodiments are shown;

[0030] Figure 6 Another variant is shown;

[0031] Figure 7 Exemplary results are shown; and

[0032] Figure 8 An example of a function is shown. Detailed Description

[0033] Figure 1 An apparatus 100 showing an embodiment according to the principles of the present invention is shown. The apparatus 100 includes: at least one input interface 110 configured to receive signals; at least one hardware processor 120 (“processor”), which in addition is configured to control the apparatus 100, process the received signals, and execute program code instructions to perform at least one method of the principles of the present invention. The apparatus 100 further includes: a memory 130 configured to store program code instructions, execution parameters, at least one look-up table (LUT), etc.; and at least one output interface 140 configured to output the processed signals. A non-transitory computer-readable medium 150 stores program code instructions that, when executed by a processor (such as processor 120), implement the steps of a method of at least one embodiment according to the principles of the present invention.

[0034] In the embodiments described below, it is assumed that the input signal x is obtained, for example, from an external device (not shown), retrieved from a memory, or as a result of an internal calculation. The result can be output or used, for example, in further calculations.

[0035] Figure 2Shows a first embodiment of method 20 according to the principles of the present invention. In the first embodiment, in step S22, the processor 120 first applies the pre-function w = P(x) to the input signal x, and then in step S24 applies the main function f w (w) to the result of the pre-function, where the main function f w (w) is represented in a LUT defined over a grid Gw of values in such a way that the pre-function is defined piecewise over a grid Gx of signal values, where Gw = P(Gx).

[0036] The pre-function P(x) is monotonically increasing and thus invertible. Apart from the monotonic increasing restriction, the pre-function and the LUT can be of any type and characteristics. For example, the piecewise pre-function P(x) can consist of one or more of logarithmic, sigmoid, exponential, polynomial type, and linear segments.

[0037] If the signal x is n-dimensional, various possibilities arise. The pre-function can also be n-dimensional. Alternatively, the pre-function can be one-dimensional and applied to each of the coordinates of x. As long as at least one coordinate of the signal x is processed by the pre-function, multiple different pre-functions with different dimensions can also be used.

[0038] Figure 3 Shows a second embodiment of method 30 according to the principles of the present invention, where the pre-function P(x) is defined piecewise over the grid Gx and used as the pre-function of the LUT, and the LUT is applied using interpolation of the LUT entries over the grid Gw = P(Gx).

[0039] For example, if the pre-function P(x) is chosen to be piecewise linear in Gx, the inverse function is piecewise linear in Gw. Then linear interpolation of the grid Gw = P(Gx) is used to apply the LUT to the signal w = P(x). In other words, the LUT output signal is interpolated from the LUT entries using linear interpolation.

[0040] In another example, the pre-function P(x) is chosen to be log2(x + 1) in the range [0, 0.41], which is part of Gx. After applying P(x), the signal w = P(x) is obtained. The inverse pre-function is 2w - 1, which is linear in the range [0; 0.5], which is part of Gw. The output signal is calculated as a linear interpolation of the LUT entries at the grid values 0 and 0.5 of the grid Gw.

[0041] In step S32, the processor 112 obtains a prefunction P(x) defined piecewise on a first grid Gx of the signal x. In step S34, the prefunction is applied to the signal x, thereby generating a first processed signal w = P(x). In step S36, a LUT is calculated using a second grid Gw = P(Gx). In step S38, the LUT is applied to the first processed signal w using linear interpolation of the LUT entries on the grid Gw to obtain a second processed signal.

[0042] In Figure 4 a first variant method 40 of the second embodiment shown in -1 (w) to obtain a concatenated function called an "adaptation function" f w (w) = f(P -1 (w)), and calculating the LUT by sampling the concatenated function on a second grid Gw in step S44.

[0043] It can be seen that this variant constructs an adapted LUT from the prefunction P(x) and the second main function f(x), thereby ensuring that applying the prefunction and the LUT to a signal is equivalent to directly applying the second main function to the LUT application error. For example, when using the prefunction P(), by sampling the concatenated and adapted function f w (w) = f(P -1 (w)) on the regular grid Gw of the signal w = P(x), an adapted regular LUT is defined on the grid Gw of the signal w. The grid Gw of the signal w corresponds to the grid Gx of the signal x. If Gx is represented as G x = {x i , 0 ≤ i < I}, then Gw can be represented as G w = P(G x ) = {P(x i ), 0 ≤ i < I}. If Gw is regular and P() is non-linear, then Gx is an irregular grid.

[0044] In a second variant (which is Figure 5 a variant method 50 of the first and second embodiments shown in

[0045] In step S52, the pre - function Q(x) is applied to the grid Gx of signal values x to obtain a second grid Gw = Q(Gx). In step S54, the pre - function P(x) that is piece - wise defined on the grid Gx is obtained by linearly interpolating the values of the grid Gw. The effect is Gw = P(Gx) = Q(Gx). In step S56, the pre - function P(x) is applied to the signal x to obtain a second signal w = p(x). In step S58, the LUT is applied to the second signal using linear interpolation.

[0046] The second variant can be useful because Q(x) is generally not a piece - wise defined function (since Q(x) is deliberately chosen). For example, Q(x) can be chosen to affect the accuracy of the LUT. Then, the piece - wise defined function P(x) is an approximation of Q(x).

[0047] Using the second variant, the implementation can be easily integrated into a conventional framework that uses a non - piece - wise defined pre - function Q(x). Assume that the conventional framework includes applying the pre - function Q(x) to the signal x such that w = Q(x), and calculating an adaptive look - up table LUT -1 by sampling an adaptation function f(Q Q (w)) on a regular grid Gw = Q(Gx) Q (w)=PL w (f(Q -1 (w)) and applying the adaptive LUT to the signal w using linear interpolation, where PL w is piece - wise linearized based on regular sampling of w.

[0048] Using the second variant, the conventional process is changed as follows: applying the pre - function P(x) to the signal x such that w = P(x), calculating an adaptive look - up table LUT -1 by sampling an adaptation function f(P p (w)) on a regular grid Gw = P(Gx)=Q(Gx) p (w)=PL w (f(P -1 (w))) and applying the adaptive LUT p to the signal w using linear interpolation, where PL w is piece - wise linearized based on regular sampling of w.

[0049] Note that if the interpolation used is conservative, when the standard pre - function Q(x) is replaced by the pre - function P(x) according to the principles of the present invention, the grid Gw does not change because Gw = P(Gx)=Q(Gx) holds. Thus, the adaptive look - up table LUT P is equal to the adaptive look - up table LUT QIts advantage is that when replacing Q(x) with P(x), there is no need to recalculate the lookup table.

[0050] In the following, an example of the second variant is given. The standard prefunction Q(x) for a one-dimensional signal in the range [0; 1] used in the conventional solution is the logarithmic function Q(x) = log2(x + 1). Using the regular one-dimensional adaptation LUT of size 3 defined by G w ={0; 0,5; 1}, the grid for defining the piecewise linear prefunction P(x) will be G_x = {f(Q^(-1)(0); f(Q^(-1)(0.5)); f(Q^(-1)(1))} = {0; 0.41; 1}. For example, in the interval [0; 0,41], the piecewise linear prefunction will be In the corresponding interval 0 ≤ w < 0.5, linear interpolation will be used when applying the adaptation LUT. This linear interpolation corresponds to the inversion of the prefunction segment defined on the interval [0; 0,41].

[0051] Figure 6 A third variant of method 60 of an embodiment according to the principles of the present invention is shown. In step S62, a second grid Gw = Q(Gx) is obtained by applying the prefunction Q(x) to the signal value x of the first grid Gx. In step S64, the prefunction w = P(x) is applied to the signal x to obtain a first processed signal w. In step S66, the LUT is calculated using the second grid Gw = P(Gx). In step S68, the LUT is applied to the first processed signal w using P(x) as the interpolation function.

[0052] Figure 7 An exemplary result is shown. It can be seen that compared with the LUT application with a linearized prefunction 74 (one point, a dashed line), a prefunction 76 (two points, a dashed line), or no prefunction 78 (a dashed line) according to the principles of the present invention, using a lookup table with a prefunction 72 (a short dashed line, a long dashed line) having the shape of the second main function based on the principles of the present invention makes the second main function 70 (a solid line) closest.

[0053] In the third variant (which is a variant of the first and second embodiments), the piecewise prefunction is further selected according to the second main function.

[0054] For at least one segment of the prefunction, the curvature of the second main function is analyzed in at least one interval corresponding to the segment of the prefunction.

[0055] In at least one interval corresponding to at least one segment, the shape of the prefunction for the at least one segment is modified according to the shape of the second main function.

[0056] For an interval of values x corresponding to at least one segment, the LUT application error is calculated. The LUT application error is the difference between the result of applying the second main function to the signal x and the result of applying the LUT according to the principles of the present invention after applying the pre-function to the signal x.

[0057] The analysis, modification of the shape, and calculation of the LUT application error are repeated until the LUT application error has been sufficiently reduced, for example, below a given value or as a ratio of the initial error.

[0058] An example of the first way to modify the shape of the pre-function is: if the second main function is convex in at least one corresponding interval, the concave curvature of that segment of the pre-function is determined, and vice versa, as will now be shown.

[0059] Continuing the above example, using a linearized logarithmic pre-function and a LUT of size 3, the pre-function can be selected according to the second main function in the following manner. Figure 8 The second main function f(x) which is concave in the interval [0; 0,41] of the piecewise-defined pre-function is shown. Therefore, a convex term g(x) is added, resulting in a modified pre-function R(x):

[0060]

[0061] where

[0062]

[0063] where the parameters a and b allow for further adaptation of the convex term of the second main function. For example, the convexity in the interval [0; 0, 41] can be controlled by the parameters and the parameter b = 0.5 - 0 = 0.5, and allows the convexity to be placed within the interval [0; 0, 41] such that g(0) = 0 and g(0.41) = 0.

[0064] If the input signal is multi-dimensional, the concavity or convexity of the second main function can be analyzed channel by channel. For example, if the second main function is analyzed for a specific channel (the corresponding channel of the pre-function), or in the case of a one-dimensional pre-function, the pre-function applied to that channel is modified according to the principles of the present invention.

[0065] Figure 8Shows the second main function f(x)80 (dots, dashed line) that is concave within the interval [0; 0,41], the increasing convex term g(x)82 (dashed line) that is zero at 0 and 0.41, the piecewise linear prefunction P(x)84 (solid line) according to the principles of the present invention, and the modified prefunction R(x)86 (two dots, one dashed line) according to the principles of the present invention that is convex within the interval [0; 0.41].

[0066] Conveniently, due to the following two reasons, the added convex term g(x) is zero at the boundaries of the interval. First, the effective irregular sampling of x introduced by the piecewise linear prefunction Q(x) is the same as the effective irregular sampling for the modified prefunction R(x), i.e., when Q(X) is replaced by R(X), the meshes Gw and Gx remain unchanged. Second, when calculating the adaptive LUT, neither R(x) nor g(x) needs to be inverted because for all w on the mesh, Gw holds f(Q -1 (w)) = f(R -1 (w)).

[0067] The second way to modify the shape of the prefunction is to optimize the shape of at least one segment in the prefunction Q(x) relative to the shape of the second main function in at least one corresponding interval such that the LUT application error is minimized. This method is trivial for one-dimensional LUTs, but since R(x) can become as non-linear as the second main function and the complexity gain of replacing the second main function with a LUT is lost by applying a complex prefunction, this method is of little significance. However, in the case of multi-dimensional LUTs, optimizing the piecewise-defined prefunction or the added concave term to minimize the LUT application error (in the average over multiple dimensions) may be meaningful. For example, modify the piecewise linear prefunction using the term g(x) as described above to become the non-linear prefunction R(x). Then, optimize the parameters a and parameter b to minimize the LUT application error.

[0068] Therefore, it will be understood that the principles of the present invention can reduce the LUT application error, i.e., the error introduced when representing the second main function as a LUT and applying it to a signal, and the piecewise linear prefunction itself can be implemented as a LUT.

[0069] It should be understood that the elements depicted in the drawings can be implemented in various forms of hardware, software, or a combination thereof. Preferably, these elements are implemented in a combination of hardware and software on one or more appropriately programmed general-purpose devices that may include a processor, a memory, and an input / output interface.

[0070] This specification illustrates the principles of the present disclosure. Accordingly, it is to be understood that those skilled in the art will be able to devise various arrangements, which, although not explicitly described or shown herein, embody the principles of the present disclosure and are included within its scope.

[0071] All of the examples and conditional language recited herein are for pedagogical purposes to aid the reader in understanding the principles of the present disclosure and the concepts contributed by the inventor to further the art, and are to be construed as not being limited to such specifically recited examples and conditions.

[0072] Moreover, all statements herein reciting principles, aspects, and embodiments of the present disclosure, as well as specific examples thereof, are intended to encompass their structural and functional equivalents. Additionally, it is intended that such equivalents include both currently known equivalents and equivalents developed in the future, i.e., any elements developed that perform the same function regardless of structure.

[0073] Thus, for example, those skilled in the art will understand that the block diagrams presented herein represent conceptual diagrams of illustrative circuits embodying the principles of the present disclosure. Similarly, it should be understood that any flowcharts, flow diagrams, etc. represent various processes that may be substantially represented in a computer-readable medium and executed by a computer or processor, whether or not such computer or processor is explicitly shown.

[0074] The functions of the various elements shown in the figures can be provided by using dedicated hardware as well as hardware capable of executing software in association with appropriate software. When provided by a processor, the functions can be provided by a single dedicated processor, a single shared processor, or by multiple individual processors, some of which may be shared. Moreover, the explicit use of the terms "processor" or "controller" should not be construed to refer exclusively to hardware capable of executing software and may implicitly include, but is not limited to, digital signal processor (DSP) hardware, read-only memory (ROM) storing software, random access memory (RAM), and non-volatile storage devices.

[0075] Other conventional and / or custom hardware may also be included. Similarly, any switches shown in the figures are conceptual only. Their functions can be carried out through the operation of programming logic, through dedicated logic, through the interaction of programming control and dedicated logic, or even manually, as will be more specifically understood from the context, by the particular techniques selectable by the implementer.

[0076] In the claims of this specification, any element expressed as a means for performing a specified function is intended to cover any way of performing that function, including, for example, a) a combination of circuit elements that perform that function, or b) software in any form, including firmware, microcode or the like, combined with appropriate circuitry for executing that software to perform that function. The disclosure as defined by these claims lies in the fact that the functions provided by the various recited means are combined and brought together in the manner claimed in the claims. Accordingly, any means that can provide those functions is considered equivalent to those illustrated herein.

Claims

1. A method, the method being executed in a device and comprising: Applying a pre - function w = P(x) to an input signal x to obtain a first result w; And Apply a look-up table (LUT) to the first result w, where the LUT represents a main function f defined for a second grid Gw of values w (w), such that the pre-function P(x) is defined piecewise on a first grid Gx of signal values, where Gw = P(Gx);​ Wherein the pre - function P(x) is obtained from a second pre - function Q(x) by: applying Q(x) to the signal value x to calculate the second grid Gw = Q(Gx), and defining the pre - function P(x) piece - wise on the first grid Gx by linear interpolation of the values of the second grid Gw such that P(Gx)=Q(Gx).

2. The method according to claim 1, wherein the signal x is n - dimensional, and the pre - function P(x) is applied to less than all n dimensions of the signal x.

3. The method according to claim 1, further comprising: Obtaining the pre - function P(x) defined piece - wise on the first grid Gx of the signal x; And Calculating the LUT using the second grid Gw = P(Gx).

4. The method according to claim 1, wherein the LUT is calculated by: Concatenate the inverse function \(P^{-1}(w)\) of the pre - function \(P(x)\) and the second main function \(f(x)\) to obtain the main function \(f(w)\) as the concatenated function \(f(w)=f(P^{-1}(w))\); and -1 (w) and the second main function f(x) are concatenated to obtain the main function f w (w) as the concatenated function f w (w) = f(P -1 (w)); and Sampling the concatenated function on the second grid Gw.

5. The method according to claim 4, wherein the pre - function is obtained by: For at least one segment of the pre - function P(x), analyzing the curvature of the second main function f(x) in at least one interval corresponding to the segment of the pre - function P(x); Modifying the shape of the pre - function P(x) for the at least one segment according to the shape of the second main function f(x); Calculating the LUT application error for an interval of values x corresponding to the at least one segment; and Iterating until the LUT application error is less than a given value.

6. A device, comprising: A memory configured to store program code instructions executable by a processor; And At least one hardware processor configured to execute the program code instructions to: Apply a pre - function w = P(x) to an input signal x to obtain a first result w; And Apply a look-up table (LUT) to the first result w, where the LUT represents a main function f defined for a second grid Gw of values w (w), such that the pre-function P(x) is defined piecewise on a first grid Gx of signal values, where Gw = P(Gx);​ Wherein the pre - function P(x) is obtained from a second pre - function Q(x) by: applying Q(x) to the signal value x to calculate the second grid Gw = Q(Gx), and defining the pre - function P(x) piece - wise on the first grid Gx by linear interpolation of the values of the second grid Gw such that P(Gx)=Q(Gx).

7. The device according to claim 6, wherein the signal x is n - dimensional, and the pre - function P(x) is applied to less than all n dimensions of the signal x.

8. The device according to claim 6, wherein the at least one hardware processor is further configured to execute the program code instructions to: Obtain the pre - function P(x) defined piece - wise on the first grid Gx of the signal x; and Calculate the LUT using the second grid Gw = P(Gx).

9. The device according to claim 6, wherein the LUT is calculated by: Concatenate the inverse function \(P^{-1}(w)\) of the pre-function \(P(x)\) and the second main function \(f(x)\) to obtain the main function \(f(w)\) as the concatenated function \(f(w)=f(P^{-1}(w))\); and -1 (w) and the second main function f(x) are concatenated to obtain the main function f w (w) as the concatenated function f w (w) = f(P -1 (w)); and Sampling the concatenated function on the second grid Gw.

10. The apparatus according to claim 9, wherein the pre-function P(x) is obtained by: For at least one segment of the pre-function P(x), analyzing the curvature of the second main function f(x) in at least one interval corresponding to the segment of the pre-function P(x); Modifying the shape of the pre-function P(x) for the at least one segment according to the shape of the second main function f(x); Calculating the LUT application error for the interval of values x corresponding to the at least one segment; and Iterating until the LUT application error is less than a given value.

11. A non-transitory computer-readable medium storing program code instructions which, when executed by a processor, implement the steps of the method according to at least one of claims 1 to 5.

Images