WO2006136978A1

WO2006136978A1 - Method and system for rendering image data on a 3d display

Info

Publication number: WO2006136978A1
Application number: PCT/IB2006/051909
Authority: WO
Inventors: Reinout Verburgh
Original assignee: Koninklijke Philips Electronics N.V.
Priority date: 2005-06-22
Filing date: 2006-06-14
Publication date: 2006-12-28

Abstract

A method and a system are provided for rendering image data on a 3D display. An angle beta is determined for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to an axis of the display. A first distance delta is calculated using the angle beta. The depth of ray at each pixel is compared with actual depth of a depth curve from the desired output pixel for the first distance delta. A cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve is then determined. A pixel on the image plane which corresponds to the cross point is selected and the luminance value of the selected pixel is used at the desired output pixel. The resulting images displayed on a 3D display are sharper than previously obtained and the computational load on a rendering system is reduced.

Description

Method and system for rendering image data on a 3D display

This invention pertains in general to the field of image signal processing. More particularly, the invention relates to processing image signals for display on a 3D lenticular display and more particularly to preserving the perceived image quality of a signal when rendering image signals for display on a 3D lenticular display.

3D imagery is a function of binocular parallax, which provides relative depth perception to the viewer. As an image of a fixated object falls on disparate retinal points, the resulting retinal disparity provides stimulus from which the sense of stereopsis is created by the viewer's visual system. Within the visual system separate neurological sub- systems specializing in different aspects of stereopsis such as fine or coarse stereopsis, or motion- in- depth, static or lateral motion stereopsis performing in combination or separately based upon the stimulus, create a 3D image for the viewer. Various means whereby 2D images may be presented to the viewer's visual system as 3D images are currently in existence. In WO 99/05559 a method for controlling pixel addressing of a display device to drive the display device as an multi-view auto-stereoscopic display when a lenticular screen is overlaid and image data for multiple views to be interlaced is provided. Based on data defining at least the lenticular screen lenticule pitch, and the global lenticular screen position relative to the display device, for each display colour pixel, a derivation is made as to which of the N views it is to carry. The corresponding pixel data for the assigned view is then selected as the display pixel data. Although the image quality of the multi-view display device controlled on basis of the method as described in WO 99/05559 is relatively good, the amount of signal processing needed to produce the displayed image is quite large.

Current 3D graphic systems utilizing 2D raster displays typically achieve realistic 3D effects by rendering objects on the 2D graphics raster display using perspective algorithms. As mentioned above, a format that is suited for multi-view rendering is 2D enriched with a depth channel, i.e. for each point in the scene, the distance of the point to the camera is known. The 2D plus depth format represents a subset of the full 3D model of the world. Rendering for multi-view screens can be accomplished by projecting this subset onto the image plane from multiple viewpoints (other camera positions than the original position). This is depth map based rendering. It is a way of 3D image warping.

Most of the common algorithms are so called forward mapping algorithms. They map pixels from the input grid to the output grid. As a result, the density of the mapped pixels is not uniform in the output domain. In other words, they do not coincide with the output grid. This means the signal needs to be resampled. In general, a resampling procedure can be seen as a four step process: reconstruct a continuous signal from the sampled terrain data; deform the continuous signal to the desired output domain; band limit the deformed signal; and sample the band limited signal. These stages require complex and expensive filters and also place a large demand on the system memory.

Moreover, the rendering stage has to deal with the introduced occlusion: in a view different from the camera view, some background pixels are hidden by foreground objects. In addition, some pixels that were not recorded by the camera, become visible in other views. Forward mapping techniques need some kind of occlusion detection (say image segmentation) to deal with this problem.

Hence, an improved signal processing system would be advantageous and in particular a rendering system which creates a 3D display from 2D image data while overcoming the occlusion and uncovering problems associated with known forward mapping techniques.

Accordingly, the present invention preferably seeks to mitigate, alleviate or eliminate one or more of the above-identified deficiencies in the art and disadvantages singly or in any combination and solves at least the above mentioned problems by providing a method, a signal processing system, a display apparatus, and a computer-readable medium according to the appended patent claims.

The present invention discloses a way of backward rendering that provides an efficient rendering of image data on a 3D display. In other words, starting from the output grid, a search for the correct input information is performed. This is done by shooting an imaginary ray starting from the viewpoint and going through the desired output pixel. The extension of this ray will cross a depth curve at the desired input point. The concept of starting from the wanted output eliminates several problems of forward mapping techniques, for instance two common problems with forward mapping techniques: holes and double assignments. Furthermore, the ray tracing principle handles covering in a very efficient way. The first pixel, which the imaginary ray hits, determined by a first cross point of the ray with the depth curve, is the one that will be visible. Uncovering pixels, like all pixels, are interpolated between two existing input pixels using linear interpolation.

According to aspects of the invention, a method, a system, an apparatus, and a computer-readable medium for rendering image data on a 3D display are disclosed.

According to one aspect of the invention, a method is provided for rendering image data on a 3D display, said method comprising the steps of: determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; calculating a first distance delta using said angle β, comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta; determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; selecting a pixel on the image plane which corresponds to the cross point; and using a luminance value of said selected pixel at said desired output pixel. According to another aspect of the invention, a signal processing system for rendering image data on a 3D display, comprising: means for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; means for calculating a first distance delta using said angle β; means for comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta; means for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; means for selecting a pixel on the image plane which corresponds to the cross point; means for using a luminance value of said selected pixel at said desired output pixel.

According to yet another aspect of the invention, a computer-readable medium having embodied thereon a computer program for rendering image data for 3D display for processing by a computer, the computer program comprising: a code segment for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; a code segment for calculating a first distance delta using said angle β; a code segment for comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta; a code segment for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; a code segment for selecting a pixel on the image plane which corresponds to the cross point; a code segment for using luminance value of said selected pixel at said desired output pixel. The present invention has for instance the advantage over the prior art that it reduces the computational load on a rendering system while maintaining the perceived image quality of the image displayed on a 3D display.

These and other aspects, features and advantages of which the invention is capable of will be apparent and elucidated from the following description of embodiments of the present invention, reference being made to the accompanying drawings, in which

Fig. 1 illustrates a schematic perspective view of a multi-view display device which may be used with the various embodiments of the invention;

Fig. 2 illustrates the concept of the ray tracing Tenderer of one embodiment of the invention;

Fig. 3 illustrates the calculation of a cross point of one embodiment of the invention; Fig. 4 illustrates focus depth rendering of one embodiment of the invention;

Fig. 5 illustrates border processing of one embodiment of the invention;

Fig. 6 illustrates the covering process of one embodiment of the invention;

Fig. 7 illustrates the uncovering process of one embodiment of the invention; and Fig. 8 illustrates the depth LUT (Look Up Table) process of one embodiment of the invention;

Fig. 9 illustrates a processing system according to one embodiment of the invention; and

Fig. 10 illustrates a computer readable medium according to one embodiment of the invention.

The following description focuses on an embodiment of the present invention applicable to video display systems and in particular to a 3D video display system. However, it will be appreciated that the invention is not limited to this application but may be applied to many other video or image display systems. In addition, the invention applies to any type of image data such as, for example, video signals, still images, etc., although the calculation load savings is of greater significance for video since it requires real-time processing. Briefly, the ray tracing Tenderer according to the invention is a fairly uncomplicated process that needs no expensive and difficult to design filters. The process scans only in one direction and needs only a small amount of memory. Problems like occlusion are handled inherently by the nature of the process, which means there is no need for segmentation of the images. The resulting images are in addition sharper than previously obtained.

In the following example, a direct-view type of 3D-LCD lenticular array display device 10 having a slanted arrangement of lenticulars will be initially described with reference to Fig. 1 in order to illustrate the present invention. It will be understood that the Figures are merely schematic and are not drawn to scale. For clarity of illustration, certain dimensions may have been exaggerated while other dimensions may have been reduced. Also, where appropriate, the same reference numerals and letters are used throughout the Figures to indicate the same parts and dimensions.

Referring to Fig. 1, the display device 10 includes a conventional LC (Liquid Crystal) matrix display panel 11 used as a spatial light modulator and comprising a planar array of individually addressable and similarly sized light-generating elements 12 arranged in aligned rows and columns perpendicularly to one another. While only a few light-generating elements are shown, there may be any arbitrary number of columns and rows of display elements, e.g. 800x600, 1600x1200, 1920x1080, etc. Such panels are well known and will not be described here in detail.

The light-generating elements 12 are substantially rectangular in shape and are regularly spaced from one another with the light-generating elements in two adjacent columns being separated by a gap extending in column (vertical) direction and with the display elements in two adjacent rows being separated by a gap extending in the row (horizontal) direction. The panel 11 is of the active matrix type in which each light- generating element is associated with a switching element, comprising for example, a TFT or thin film diode, TFD, situated adjacent the light-generating element.

The display panel 11 is illuminated by a light source 14, which, in this example, comprises a planar backlight extending over the area of the display element array. Light from the source 14 is directed through the panel with the individual light-generating elements being driven, by appropriate application of drive voltages, to modulate this light in conventional manner to produce a display output. The array of light-generating elements constituting the display produced thus corresponds with the structure of light-generating elements, each light-generating element providing a respective display pixel. A processing unit 18 computes luminance values for the respective light-generating elements as will be explained below in more detail.

Over the output side of the panel 11, opposite that facing the light source 14, there is disposed a lenticular sheet 15 comprising an array of elongate, parallel, lenticules, or lens elements, acting as optical director means to provide separate images to each of a viewer's eyes, respectively, producing a stereoscopic display to a viewer facing the side of the sheet 15 remote from the panel 11. The lenticules of the sheet 15, which is of conventional form, comprise optically (semi) cylindrically converging lenticules, for example, formed as convex cylindrical lenses or graded reflective index cylindrical lenses. Autostereoscopic display device using such lenticular sheets in conjunction with matrix display panels are well known in the art although, unlike the conventional arrangement in such apparatus, with lenticules extending parallel to the display pixel columns (corresponding to the display element columns), the lenticules in the apparatus of Fig. 1 are arranged slanted with respect to the columns of the light-generating elements, that is, their main longitudinal axis is at an angle to the column direction of the structure of light-generating elements. This arrangement has been found to provide a number of benefits in terms of reduced resolution loss and enhanced masking of the black area between light-generating elements, as is described in the patent application with number EP-A-0791 847. The description of the operation of the display illustrated in Fig. 1 is described in patent application PHNL050033EPP which is incorporated herein by reference.

The ray tracing rendering process according to one embodiment of the invention will now be described with reference to Figs. 2 and 3. It will be understood by those skilled in the art that the rendering process conceptually illustrated in the drawings is actually performed in at least one processing device. In this illustrative example, the view depth 204 from the viewpoints n, n+1, etc., to the image plane 206 is known. For example, the view depth may equal 8192. In addition, the size of a depth scale (dscale) 208 is also known, e.g. 256. As noted above, the 2D image data also includes depth information. The depth information for each pixel is put together to form a depth curve 210. The depth curve 210 is located within the dscale 208. Conceptually, to find the correct output for a pixel x_p an imaginary ray is shot from the viewpoint through the pixel x_p to determine the cross point of the ray 212 and the depth curve 210. The ray 212 is created mathematically by the processing unit 18 using the known viewpoint location, view depth and x_p location. First, the tangent of the angle β between the ray 212 and the vertical axis is calculated by tan(β) = (viewpoint - x_p) / view depth

Using the tangent of β, the processing unit 18 can determine a value delta by

delta = (dscale*(x_p - viewpoint))/view depth

which represents the area within which the ray 212 should have intersected the depth curve 210. For all values between x_p and x_{p + de}l_ta, the depth of the ray (DR) is compared to the actual depth of the depth curve 210. The DR for each pixel Xi is calculated by

DR(Xi) = view depth* ABS((xi - x_p)/x_p - viewpoint). For example, the depth of the ray DR(x_p) for pixel x_p is compared to the actual depth of the depth curve 210 for pixel x_p. If DR(Xp) is less than the actual depth of the depth curve 210, the DR for the next pixel in the direction of x_{p + de}l_ta is calculated and compared to the depth curve. These calculations continue for each pixel between x_p and x_{p + de}l_ta until the DR for a pixel is equal to or greater than the actual depth of the depth curve. When DR is equal to or greater than the actual value of the depth curve for the first time, the cross point of the ray and the depth curve has been found. The pixel X₀ in the image plane which corresponds to the cross point is then determined. The luminance value for the pixel x_c is then used as the luminance value for the pixel x_p. As illustrated in Fig. 3, if the cross point occurs between pixel Xi and pixel Xi_-1, the actual output value can be calculated in a variety of ways, for example, as a weighted average (linear interpolation), using a polyphase filter, etc., from the input pixels corresponding to the positions Xi and Xi_-1. For example, the processing system 18 can calculate the output value as follows:

prev depth diff = ABS(DePtIi(Xi_-1) - DR(X_1-1)) cur depth diff = ABS(Depth(xO - DR(X₁)) tot depth diff = pre v depth diff + cur depth diff output^(prev_depth_diff * texel(xi) + cur depth diff * texel(xi_ O/tot depth diff One can see that for all pixels having a depth different from zero, the output pixels are warped/shifted versions of the input pixels. As a result, all image parts having a depth other than zero are less sharp than the original input. Because the image part with zero depth is rarely the object of interest, the concept (in analogy with cameras) of focus depth is introduced. The focus depth is meant to put the plane of interest (which typically consists of the object of the scene) in focus. In this way, the resulting image looks much sharper and the image parts with depth bigger than focus depth fall inside the screen, while parts with a smaller depth come out of the screen. The focus depth is ideally scene dependent, but very good results are achieved with a fixed value too. Typical values are near half the depth scale. The focus depth procedure is illustrated in Fig. 4. The pixel x_p is still the wanted output pixel but the image plane is no longer at zero depth. Because the focus plane does not coincide with the zero plane 214, xi starts from a value which is different from x_p ('start x' in Fig. 4) and runs until 'end x'. This causes an introduction of delta2 in addition to the method shown in Fig. 3, otherwise the present method is basically the same. After the tangent of β has been determined, the processing system 18 determines deltal and delta2 as follows:

deltal=((dscale-focus_depth)*(x_p.viewpoint))/view_depth delta2=(-focus_depth*(x_p-viewpoint))/view_depth

Note that deltal and delta2 will always have different signs. Once deltal and delta2 have been determined, the processing system 18 starts comparing the DR for each pixel starting at pixel x_p+deita2 to pixel x_p+deitai with the actual depth for each pixel until a cross point is detected as described above with reference to Fig. 3. In this embodiment, DR(xi) is calculated by

DR(xi)=view_depth*ABS((xi-Xp)/(xp-viewpoint))

Fig. 5 schematically explains border processing according to one embodiment of the invention. Consider x_p, being the output pixel corresponding to the ray going from the viewpoint to the leftmost input pixel. In the worst case, all pixels between the border and above determined x_p (=deltal_max) have a maximum depth. This means that all output pixels between zero and this x_p are the same (repeated) leftmost pixel of the input image. A special border processing is introduced consisting of using a minimum value for the depth for all pixels between 0 and x_p. In this way the input image is folded towards the border. Note that due to the introduction of this border processing, more pixels than the possible maximum amount of repeated pixels are warped. Indeed, the pixels between x_p and x_p' are possibly also modified. In other words, the border is enlarged while making it less visible. In this embodiment, the tangent of the angle β between the ray 212 and the vertical axis is calculated by

tan(β)= (viewpoint)/(view_depth+dscale) = deltalmax/(dscale-focus_depth) where deltalmax= ((dscale-focus depth) * viewpoint)/(view_depth + dscale)

For example, at the left side of the display, if pixel Xi is in the area bounded by 0 and deltalmax, then

min_border_depth=Xi/tan(β) + focus depth

=(xi*(view_depth+dscale))/viewpoint

+focus_depth

The DR for each pixel is then calculated by

DR(xi)= min(depth(xi),min_border_depth)

Fig. 6 schematically illustrates how the present invention handles covered pixels. The first cross point of the ray with the depth curve is the only visible pixel at the viewpoint. So the pixel value for the first cross point is used at pixel x_p and is determined as described above with reference to Figs. 2-3.

Fig. 7 schematically illustrates how the present invention handles uncovered pixels. The areas are simply filled with an interpolation between two existing pixels, which is no different from other areas. In other words, the pixel value is calculated as described above with reference to Fig. 3.

Image parts with a depth around the focus depth are sharp. Due to temporal fluctuations of the depth map, the sharpness of those image parts also fluctuates (in feet, the sharpness of the whole image fluctuates, but it is more visible in the sharper areas). Fig. 8 schematically illustrate a non linear transformation of the depth curve consisting of two gamma functions. The first function (fl) is valid for depth values between the focus depth and the maximum depth value (depth scale), the second function (f2) between zero and the focus depth. With this curve, moderate variations of depth values around the focus depth will result in very small variations at the LUT output and thus yielding a more constant sharpness impression of the object in focus.

Fig. 9 illustrates an exemplary processing system 900 according to a further embodiment of the invention. According to the embodiment, the processing system 900 comprises means 902 for interpreting a depth curve received with the video data for pixels of the image; means 904 for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; means 906 for calculating a first distance delta using said angle β; means 908 for comparing depth of ray at each pixel with actual depth of the depth curve from the desired output pixel for the first distance delta; means 910 for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; means 912 for selecting a pixel on the image plane which corresponds to the cross point; means 914 for using luminance value of said selected pixel at said desired output pixel.

In another embodiment of the invention according to Fig. 10, a computer readable medium is illustrated schematically. A computer-readable medium 1000 has embodied thereon a computer program 1010 for rendering video data on a 3D display, for processing by a computer 1013. The computer program comprises a code segment 1014 for interpreting a depth curve received with the video data for pixels of the image; a code segment 1015 for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; a code segment 1016 for calculating a first distance delta using said angle β; a code segment 1017 for comparing depth of ray at each pixel with actual depth of the depth curve from the desired output pixel for the first distance delta; a code segment 1018 for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; a code segment 1019 for selecting a pixel on the image plane which corresponds to the cross point; a code segment 1020 for using luminance value of said selected pixel at said desired output pixel.

The invention can be implemented in any suitable form including hardware, software, firmware or any combination of these. The elements and components of an embodiment of the invention may be physically, functionally and logically implemented in any suitable way. Indeed, the functionality may be implemented in a single unit, in a plurality of units or as part of other functional units. As such, the invention may be implemented in a single unit, or may be physically and functionally distributed between different units and processors.

Although the present invention has been described above with reference to specific embodiments, it is not intended to be limited to the specific form set forth herein. Rather, the invention is limited only by the accompanying claims and, other embodiments than the specific above are equally possible within the scope of these appended claims, e.g. different signal processing systems than those described above.

In the claims, the term "comprises/comprising" does not exclude the presence of other elements or steps. Furthermore, although individually listed, a plurality of means, elements or method steps may be implemented by e.g. a single unit or processor. Additionally, although individual features may be included in different claims, these may possibly advantageously be combined, and the inclusion in different claims does not imply that a combination of features is not feasible and/or advantageous. In addition, singular references do not exclude a plurality. The terms "a", "an", "first", "second" etc do not preclude a plurality. Reference signs in the claims are provided merely as a clarifying example and shall not be construed as limiting the scope of the claims in any way.

Claims

CLAIMS:

1. A method for rendering image data on a 3D display, said method comprising: determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis of said display; calculating a first distance delta using said angle β, - comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta; determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; selecting a pixel on the image plane which corresponds to the cross point; - using luminance value of said selected pixel at said desired output pixel.

2. The method according to claim 1 , wherein tangent of angle β is determined by tan(β)= (viewpoint - x_p)/view depth.

3. The method according to claim 1, wherein the first distance delta is determined by: delta= (dscale*(x_p - viewpoint))/view depth, wherein dsacle is the size of a depth scale.

4. The method according to claim 1, wherein the depth of ray (DR) value for each pixel is determined by

DR(Xi) = view depth* ABS((xi - x_p)/x_p - viewpoint).

5. The method according to claim 1, wherein the luminance value is calculated as a weighted average between two pixel values when the cross point occurs between two pixels.

6. The method according to claim 5, wherein the luminance value is calculated using an interpolation technique.

7. The method according to claim 6, wherein the luminance value is calculated using linear interpolation.

8. The method according to claim 6, wherein the luminance value is calculated using a polyphase filter.

9. The method according to claim 5, wherein the luminance value is calculated by prev depth diff = ABS(DePIh(Xi_-1) - DR(Xi_-1)) cur depth diff = ABS(Depth(xi) - DR(xO) tot depth diff = prev depth diff + cur depth diff output^(prev_depth_diff*texel(xi)+cur_depth_diff* texe^Xi.^/tot depth diff, wherein DR is the depth of ray (DR) value for a pixel x.

10. The method according to claim 1, wherein the image plane has zero depth.

11. The method according to claim 1 , wherein the image plane has a non-zero depth.

12. The method according to claim 11, wherein the first distance delta is calculated by delta = ((dscale-focus_depth)*(x_p.viewpoint))/view_depth.

13. The method according to claim 12, further comprising the step of: calculating a second distance delta by delta2=(-focus_depth*(x_p-viewpoint))/view_depth.

14. The method according to claim 13, wherein the depth of ray for each pixel is determined by

DR(xi)=view_depth*ABS((xi-Xp)/(xp-viewpoint)).

15. The method according to claim 1, wherein the depth curve information is included with the image data.

16. A signal processing system for rendering image data on a 3D display, comprising: means (904) for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; means (906) for calculating a first distance delta using said angle β, means (908) for comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta; means (910) for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; means (912) for selecting a pixel on the image plane which corresponds to the cross point; means (914) for using luminance value of said selected pixel at said desired output pixel.

17. A display apparatus for rendering image data for 3D display, comprising: a display unit (10); a processing unit (18) comprising:

- means (904) for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis;

- means (906) for calculating a first distance delta using said angle β,

- means (908) for comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta;

- means (910) for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve;

- means (912) for selecting a pixel on the image plane which corresponds to the cross point;

- means (914) for using luminance value of said selected pixel at said desired output pixel on the display.

18. A computer-readable medium (1000) having embodied thereon a computer program (1010) for rendering image data for 3D display for processing by a computer (1013), the computer program (1010) comprising: a code segment (1015) for determining an angle β for an imaginary ray between a desired output pixel on an image plane and a first viewpoint relative to a vertical axis; a code segment (1016) for calculating a first distance delta using said angle β, a code segment (1017) for comparing depth of ray at each pixel with actual depth of a depth curve from the desired output pixel for the first distance delta; a code segment (1018) for determining a cross point on the depth curve where depth of ray of a pixel is equal to or greater than the actual depth of the depth curve; a code segment (1019) for selecting a pixel on the image plane which corresponds to the cross point; - a code segment (1020) for using luminance value of said selected pixel at said desired output pixel.