WO2010046792A1

WO2010046792A1 - Method of edge anti-aliasing a graphics geometry and a vectorgraphics processor for executing the same

Info

Publication number: WO2010046792A1
Application number: PCT/IB2009/054339
Authority: WO
Inventors: Kornelis Meinds
Original assignee: Nxp B.V.
Priority date: 2008-10-21
Filing date: 2009-10-05
Publication date: 2010-04-29

Abstract

The present invention is related to a method of edge anti-aliasing a graphics geometry having N polygons (A, B, C, D), comprising the steps of: (a) determining a footprint of one of the N polygons by allocating all pixels being at least partially covered by the according polygon to a merge pixel layer (ML) in a merge buffer (MB), (b) determining an amount of contribution (cov) to each pixel by the according polygon, (c) accumulating a partial color contribution (pec) from said polygon to a stored partial color contribution (pcc_store) stored for each pixel of the merge pixel layer (ML) in the merge buffer (MB) and accumulating the amount of contribution to a stored amount of contribution (cov_store) stored for each said pixel, the partial color contribution being based on the amount of contribution to the corresponding pixel and the color of the polygon, repeating steps (a) to (c) for all of the N polygons, and determining pixel colors (pc) of pixels in a display buffer (DB) by blending pixels of the merge buffer (MB) into the associated pixels of the display buffer (DB).

Description

METHOD OF EDGE ANTI-ALIASING A GRAPHICS GEOMETRY AND A VECTORGRAPHICS PROCESSOR FOR EXECUTING THE SAME

FIELD OF THE INVENTION

The invention relates to a method of edge anti-aliasing a graphics geometry, a vector graphics processor for executing the same, a graphics adapter comprising the vector graphics processor, a computer comprising the vector graphics processor, and a display apparatus comprising the vector graphics processor.

BACKGROUND OF THE INVENTION

The development of new techniques of rendering 2D vector graphics geometry is in steady progress, wherein at the time being common software libraries used to provide a vector graphics-based, device-independent API for software developers are the Cairo graphics library and the openVG library standardized by Khronos consortium. One of the tasks achieved by the common graphics libraries is the generation of smooth edges of rendered 2D surfaces also known as edge anti-aliasing technique. For the openVG 1.0 and the open VG 1.1 standard a polygon-pixel- footprint-coverage type for performing edge antialiasing can be used, wherein this technique is also used in other implementations of 2D vector graphics libraries.

A common approach to implement edge anti-aliasing of polygon-pixel- footprint-coverage type is area coverage sampling. Herein, the amount of coverage (or overlap) of a polygon to be rendered (contributing to the pixel) is calculated by means of the footprint of a prefilter of the pixel. Often for this footprint the square around the pixel (in which the pixel has to be regarded as a infinite small point at a sample grid) is taken such that the width and height of this pixel prefilter footprint has unit length, i.e. the "pixel squares" are not overlapping and they cover the whole area.

An example of such a footprint of a pixel's prefilter of a polygon S is shown in

Fig. IA. Herein, the polygon S is an axis-aligned square of 3 units width and 3 units height. The amount of gray of each pixel, which are represented by the little squares, indicates the color contribution of the polygon S and is equal to the coverage area or amount of coverage of the polygon with the little squares or pixels. In Fig. IB, two adjacent polygons A and B to be rendered by executing the known area coverage sampling method are shown. Herein, the polygon A is rendered first, wherein, in a first step, the amount of coverage of each pixel being at least partially covered by the polygon A is determined (as illustrated in Fig. IA), and then the coverage value of each pixel is used to multiply (either explicitly or implicitly) with the color value to obtain a "partial (anti-aliased) pixel color". As shown in the example of Fig. IB, the first partial pixel color of the indicated pixel square due to polygon A is written into a color buffer. Then, a second partial pixel color of the same indicated pixel due to polygon B is determined and accumulated in the color buffer. Here, "implicit" multiplication refers to pre-multiplication of the color value from the polygon by the coverage value before accumulation. "Explicit" multiplication, by contrast, refers to storage of the raw color value of the polygon, without multiplication by the coverage value. In the latter case, the coverage value must also be stored and the two values later multiplied to obtain the proper, weighted color contribution.

In the example of Fig. IB the polygons A and B have adjacent edges, it is, however, also possible to render overlapping polygons or more than two polygons overlapping a single pixel. The final color value of a single pixel will be therefore the accumulated color values of all partial anti-aliased pixel colors of all polygons covering at least partially the pixel.

However, as shown in Fig. 2, the edge anti-aliasing by area coverage sampling leads to a color shine through between adjacent anti-aliased surfaces, as should be explained by example of Fig. IB. Herein, both polygons A and B are covering the shown pixel square only partially, i.e. with an amount of coverage less than 100 percent. Assuming a background color value bigger than zero, e.g. grey, firstly partial pixel contributions of polygon A are processed and merged in an image buffer, then partial pixel contributions of polygon B are processed and merged into the image buffer. Thus, as shown in Fig. 2, a graphics geometry being subject to an area coverage sampling process shows a color shine through at adjacent anti-aliased surfaces, since in the anti-aliasing process the background is included in the calculation of the partial pixel color. This color shine through effect between adjacent anti- aliased surfaces is an undesired effect and has to be avoided.

An approach for avoiding the problem of shine through edges, which is known in the state of the art, is the Supersampling technique. Herein, jagged and pixelated edges are eliminated, wherein samples are taken at several discrete instances inside a pixel and used to approximate a coverage value. This is achieved by rendering the image at a much higher resolution than the one being displayed, wherein the image is then shrinked or downsampled to a desired size, using the extra pixels for calculation. This process results in smoother transitions from one line of pixels to another along the edges of different objects. However, the supersampling method is a relative expensive method both in terms of compute performance and memory bandwidth requirements, additionally more local memory is needed. Further, with low super sample factors, the supersampling process does give not that high edge anti-aliasing quality as often desired. Thus, increasing the super sample factor increases also the costs, since more compute resources and memory bandwidth is needed.

Another solution of avoiding color shine through between adjacent edges (as shown in Fig. 2) of the state of the art is mentioned in the context of a high-quality 2D rendering engine being known as "Anti-Grain Geometry", which is available as an open source C++ implementation. Herein, the shine through edges appearing as a thin web of bright lines on the anti-aliased image (cf. Fig. 2) is avoided by changing the anti-aliasing gamma, which is a feature in the gamma correction, and the value of dilation of the polygons. The anti-grain geometry provides a simple contour tool that can dilate or shrink the polygons. Thus, the shine through edges by using area coverage sampling as described above is avoided by expanding (dilating) all polygons such that the polygon edge, in continuous space, overlap each other.

Although this method indeed removes the shine through edges, it also reduces the quality of the edge anti-aliasing filtering. This is understandable because (if the polygon expand is big enough) the partial pixel color contribution of the first polygon (polygon A in the example of Fig. IB) is overwritten by the second polygon (polygon B) in Fig. IB and cannot contribute to a nice blended anti-aliased edge.

Also by expanding the size of the polygon the position on the screen is different as originally intended. This could lead to some strange artifacts, as should be discussed with regard to Fig. 3. Herein, a triangle strip T with adjacent thin triangles or slivers Ti to T₆ cover the pixel, which generates a final color of the pixel being the sum of the partial contributions of each of the overlapping thin triangles Ti to T₆ having the amount of coverage COV_TI to covrβ- However, if all these triangles T₁, to T₆ are expanded (dilated) in all directions by half pixel size or more, assuming that the triangles are rendered from right to left, then in the case of the example in Fig. 3, the last triangle T₆ would almost give the sole contribution to the pixel, which is far off from the desired rendering of the graphics geometry. In addition, the described technique does not work for semi-transparent polygons.

US 5,123,085 describes a method and an apparatus for rendering anti-aliased polygons. Herein, polygons with depth information for 3D graphics are rendered, wherein the final visible pixel color using depth information depends on the depth order of the pixels generated for a position on the screen. The final visible pixel color without depth information is dependent only from the order the polygons are provided. This so-called polygon-pixel coverage anti-aliasing approach uses a geometric determination and storage of the overlap of the unit pixel square with the polygon. This approach is done using a mask representing discrete sub-pixel sample positions within the unit pixel square. The approach of using a geometric coverage mask does a proper handling of adjacent polygons leading to no color shine through between adjacent edges. The masks are used to only add a proportional part of a pixel color to the frame buffer pixel according to the overlap of the pixel-mask with the free positions of the frame buffer pixel mask. Herein, all possible masks with respect to a single edge are stored into a look-up table. The proper mask index is identified according to how the edge resides within the unit pixel square. The mask is a discrete coverage approximation that can give rise to little grey values at an especially near horizontal or vertical edge. In a modified system, instead of masks for coverage a single value indicative of the fraction of coverage of a pixel is used, wherein, however a color-shine artifact could be observed.

JP 2006-106989 describes an image composition device. Herein, the image composition device is provided with an anti-aliasing processing circuit for mixing not only color information but also alpha information with each of pixels of an inputted foreground image, and for generating a foreground image, in which aliasing is reduced. The image composition device further comprises a foreground color buffer for storing the color information of the foreground image, a foreground alpha buffer for storing the alpha information of the foreground image, a background color buffer for storing the color information of the background image, and an image composition circuit for compositing the color information of the foreground image with the color information of the background image by using the alpha information of the foreground image.

JP 2003-323632 describes an image processor. Herein, the image processor comprises an image memory including a first color buffer and a second color buffer for storing the data of pixel configuring a polygon and an identification storing buffer, an identification generating block for imparting to each pixel, an identification for identifying whether or not each pixel is present on the edge of the polygon. The image processor further comprises a memory control block for storing the identification of each pixel in the identification storing buffer. The memory control block is further configured for receiving the coordinates, color value, polygon coating ratio, and identification of each pixel. In addition, it is implemented for mixing this data according to the polygon coating ratio of the pixel on the basis of the color value of the pixel and the color value stored in an address of the second color buffer corresponding to the pixel, to determine a final color value, and for storing it in the first color buffer.

OBJECT AND SUMMARY OF THE INVENTION

It is therefore an object of the present invention to provide a method of edge anti-aliasing a graphics geometry and a vector graphics processor for executing the same offering a simple way of avoiding color shine through on shared edges of adjacent surfaces in a vector graphics rendering process with high quality.

This object is achieved by the features of the independent claims.

In particular, according to one aspect of the invention, there is provided a method of edge anti-aliasing a graphics geometry having N polygons (A, B, C, D), comprising the steps of: (a) determining a footprint of one of the N polygons by allocating all pixels being at least partially covered by the according polygon to a merge pixel layer (ML) in a merge buffer (MB), (b) determining an amount of contribution (cov) to each pixel by the according polygon , (c) accumulating a partial color contribution (pec) from said polygon to a stored partial color contribution (pcc_stOre) stored for each pixel of the merge pixel layer (ML) in the merge buffer (MB) and accumulating the amount of contribution to a stored amount of contribution (cov_stOre) stored for each said pixel, the partial color contribution being based on the amount of contribution to the corresponding pixel and the color of the polygon, repeating steps (a) to (c) for all of the N polygons, and determining pixel colors (pc) of pixels in a display buffer (DB) by blending pixels of the merge buffer (MB) into the associated pixels of the display buffer (DB), wherein the pixels are blended proportionally to the accumulated stored amount of contribution for each pixel. The step of blending pixels of the merge buffer (MB) into the associated pixels of the display buffer may be performed incrementally - for example, concurrently with steps

(a) to (c) as each of the N polygons is processed. Alternatively, it may be performed as a post-processing step, after all N polygons have been processed. In other words, the ordering of the blending step with respect to steps (a) to (c) is not restricted.

Some or all of the pixels in the merge buffer may be blended into the display buffer. Other pixels in the merge buffer that are not blended into the display buffer may simply be allocated or copied to the display buffer.

According to one embodiment, there is provided a method of edge antialiasing a graphics geometry having N polygons (A, B, C, D), wherein the N polygons together form a composite polygon, the method comprising the steps of: (a) determining a footprint of one of the N polygons by allocating all pixels being at least partially covered by the according polygon to a merge pixel layer (ML) in a composite primitive merge buffer (MB); (b) determining an amount of contribution (cov) to each pixel by the according polygon, (c) accumulating a partial color contribution (pec) from said polygon to a stored partial color contribution (pcc_stOre) stored for each pixel of the merge pixel layer (ML) in the composite primitive merge buffer (MB) and accumulating the amount of contribution to a stored amount of contribution (cov_stOre) stored for each said pixel, the partial color contribution being based on the amount of contribution to the corresponding pixel and the color of the polygon, repeating steps (a) to (c) for all of the N polygons, and determining pixel colors (pc) of pixels in a frame buffer by blending all pixels of the composite primitive merge buffer (MB) proportionally to their accumulated contribution values into the associated pixels of the frame buffer.

Another embodiment of the present invention is based on the thought to provide a method of edge anti-aliasing a graphics geometry having N polygons, comprising the steps of: (a) determining a foot print of one of the N polygons by allocating all pixels being at least partially covered by the according polygon to a merge pixel layer in a merge buffer, (b) determining an amount of coverage of each pixel by the according polygon of the merge pixel layer, (c) accumulating a partial color contribution and the amount of coverage to a partial color contribution and an amount of coverage stored for each pixel of the merge pixel layer in the merge buffer, wherein a portion of the partial color contribution proportional to the amount of coverage to be accumulated exceeding 100% of the total amount of coverage is cut off and the remaining portion of the partial color contribution to be accumulated is added with the stored partial color contribution, and stored in the merge buffer as the new partial color value, (d) storing an accumulated pixel color of each pixel having a total coverage equal to or more than 100% and allocating these pixels to the display pixel layer in a display buffer, while clearing the associated pixels in the merge display layer in the merge buffer, (e) repeating steps (a) to (d) for all of the N polygons and (f) determining a pixel color of all pixels in the display buffer after rendering the N^th polygon by blending all pixels of the merge buffer proportionally to their coverage value into the associated pixels of the display buffer.

In another preferred embodiment of the present invention a method of edge anti-aliasing a graphics geometry having N polygons is provided, which comprises the steps of (a) determining a foot print of one of the N polygons by allocating all pixels being at least partially covered by the according polygon to a merge pixel layer in a merge buffer, (b) determining an amount of coverage of each pixel by the according polygon of the merge pixel layer, (c) accumulating a partial color contribution and the amount of coverage to a partial color contribution and an amount of coverage stored for each pixel of the merge pixel layer in the merge buffer, wherein a portion of the stored partial color contribution proportional to the amount of coverage to be accumulated exceeding 100% of the total amount of coverage is cut off and the partial color contribution is added with the remaining portion of the stored partial color contribution, (d) storing an accumulated pixel color of each pixel having a total coverage equal to or more than 100% and allocating these pixels to the display pixel layer in a display buffer, while clearing the associated pixels in the merge display layer in the merge buffer, (e) repeating steps (a) to (d) for all of the N polygons, and (f) determining a pixel color of all pixels in the display buffer after rendering the N^th polygon by blending all pixels of the merge buffer proportionally to their coverage value into the associated pixels of the display buffer.

In a further preferred embodiment of the present invention, the partial color contribution is equal to the amount of coverage times a color value of the according polygon, wherein the coverage value is preferably an exact computation or an approximation of the overlap of a pixel's footprint with the polygon's footprint. The pixel's footprint has to be understood as a footprint of a prefilter of a pixel, which is an infinite small point in screen space. Herein, the pixel's footprint can be rectangular or circular and can have different sizes. The area of overlap of the pixel's footprint with the polygon's footprint can be weighted according to a filter function, known as a prefilter or antialising filter, to better suppress aliasing artifacts, while keeping edges sharp. Herein, the color value consists preferably of a RGBA-value.

For an implementation of the method of the present invention, a vector graphics processor is provided, which comprises a rasterizer for executing method steps (a) and (b) for each of the N polygons, a blending and anti-aliasing unit being coupled to the rasterizer for executing method steps (c) and (d) for each of the N polygons, and method step (f) after rendering the N^th polygon, a merge buffer being connected to the blending and anti- aliasing unit for storing a partial color contribution and an amount of coverage for each pixel of the merge layer, a display buffer being connected to the blending and anti-aliasing unit for storing the pixel color for each pixel of the display pixel layer, and a frame buffer being connected to the blending and anti-aliasing unit for receiving the pixel color data.

In one embodiment of the present invention, the vector graphics processor of the present invention further comprises a path, transformation, stroke, and paint unit for defining a path to be drawn, and for setting a transformation, stroke and paint parameters, a stroked path generation unit being connected at its input to the output of the path, transformation, stroke, and paint unit for generating a stroked path by applying the stroke parameters, a transformation unit being connected at its input to the output of the stroked path generation unit for executing a transformation into a screen coordinate system, and being connected at its output to the input of the rasterizer.

In another embodiment of the present invention, the vector graphics processor further comprises a clipping and masking unit being connected at its input to the output of the rasterizer for eliminating pixels not lying within the bounds of a drawing surface; a paint generation unit being connected at its input to the output of the clipping and masking unit for defining a color and an alpha value at each pixel of the drawing surface; and an image interpolation unit being connected at its input to the output of the paint generation unit for interpolating at each pixel a color and alpha value, and being connect at its output to the input of the blending and anti-aliasing unit.

In a further preferred embodiment of the present invention the vector graphics processor is part of a graphics adapter, a computer or a display apparatus. BRIEF DESCRIPTION OF THE DRAWINGS

The above and other objects, features and other advantages of the present invention will be more clearly understood from the following detailed description taking in conjunction with the accompanying drawings. The invention will now be described in greater detail hereinafter, by way of non-limiting examples, with reference to the embodiments shown in the drawings.

Fig. IA is a schematical graphic illustrating an edge anti-aliasing process based on area coverage sampling, as known in the state of the art;

Fig. IB is a schematical graphic illustrating a rendering process including edge anti-aliasing by area coverage sampling of two polygons, as known in the state of the art;

Fig. 2 is an exemplary image showing a color shine through between adjacent surfaces caused by edge anti-aliasing by area coverage sampling of the state of the art; Fig. 3 is a schematic diagram illustrating a rendering process of a triangle strip with thin triangles leading to artifacts, as known in the state of the art;

Fig. 4 A is a schematic view illustrating the rendering process of a first polygon according to an embodiment of the present invention;

Fig. 4B is a schematic view illustrating the rendering process of a second polygon according to the same embodiment;

Fig. 4C is a schematic view illustrating the rendering process of a N^th polygon according to the embodiment;

Fig. 5 is a block diagram illustrating a vector graphics processor for executing a method according to an embodiment of the present invention; Fig. 6 shows a computer comprising a vector graphics processor according to an embodiment of the present invention, and

Fig. 7 shows a display apparatus comprising a vector graphics processor according to an embodiment of the present invention.

DESCRIPTION OF THE EMBODIMENTS

The method of edge anti-aliasing a graphics geometry according to the present invention, in which N polygons are rendered, should be described in the following by help of Fig. 4A to Fig. 4C. The present invention is based on the idea to avoid the shine through edges problem while maintaining the pixel coverage anti-aliasing approach known for its high quality edge anti-aliasing.

The key idea of the present invention is to use two layers of pixel color data, wherein the pixel color data could consist of RGBA data. Herein, the color information is contained in the RGB (red, green, blue) data, and may belong to any RGB color space. The so-called alpha value (A) enables alpha blending and alpha compositing. The alpha channel is normally used as an opacity channel, wherein values between 0 percent and 100 percent make it possible for pixels to show through a translucent foreground object like a glass, an effect being not possible with simple binary (transparent or opaque) transparency. It allows easy image compositing. Alpha channel values can be expressed as a percentage, integer or real number between 0 and 1 like the RGB parameters.

In performing the anti-aliasing method of the present invention, these two layers of pixel color data are used to contain pixel color contributions in dependency of the amount of coverage of each pixel.

The first of these two pixel data layers is called display pixel layer (indicated as DL in Fig. 4A to 4C) and contains pixel color contributions of pixels being 100 percent covered by one or more polygons. The second of these pixel layers is called merge pixel layer (indicated as ML in Fig. 4A to 4C) and is provided to contain pixel color contributions of pixels being less than 100 percent covered by one or more polygons. As shown in Fig. 5, the merge pixel layer ML is stored in a merge buffer MB and the display pixel layer DL is stored in display buffer DB, which will be explained later.

In the following, the procedure according to a first embodiment of the method of the present invention should be explained.

Fig. 4A shows a rendering step of a first polygon A. Herein, a footprint of the first polygon A is determined by allocating all pixel squares (indicated simply as pixels in the following) being at least partially covered by the polygon A to a merge pixel layer ML. It should be noted that the term pixel squares is mainly understood as unit squares around pixel samples according to a box prefϊlter footprint. In a second step, an amount of coverage COV_A of each pixel by the polygon A of the merge pixel layer ML is determined. As shown in Fig. 4A, there are two groups of pixels, one of them are covered less than 100 percent by polygon A, and the other group of pixels is covered equal to 100 percent by the polygon A. All pixels being fully covered by polygon A are allocated to and overwrite the value in the display layer DL, wherein a pixel color pc of each pixel of the display pixel layer DL is calculated on the basis of the color data of the polygon A. Herein, the value of the according pixel in the merge pixel layer is cleared.

In the remaining pixels of the merge pixel layer ML, a partial color contribution pcc_stOre and the amount of coverage cov_stOre are stored in the merge buffer MB (as shown in Fig. 5), wherein the partial color contribution pcc_stOre is equal to the color value of the polygon A times the amount of coverage COV_A of each pixel of the merge pixel layer ML by the polygon A.

In Fig. 4B a rendering process of a second polygon B using the method of edge anti-aliasing a graphics geometry according to the present invention is illustrated. For the sake of illustration, the polygon B has one edge being adjacent to the polygon A. However, it should be noted, that the scenario as shown in Fig. 4B should not be considered as constricting, since the second polygon B to be rendered could be located at any place in the pixel grid. In addition, it is possible that polygon B overlaps with polygon A.

In a first step, again a footprint of the polygon B is determined and all pixels being at least partially covered by the according polygon are allocated to the merge pixel layer ML. After determining an amount of coverage COV_B of each pixel by the polygon B of the merge pixel layer ML, pixels being fully covered by the polygon B are allocated to the display pixel layer DL and a pixel color pc is stored for each pixel in the display pixel layer DL.

Further, a partial color contribution pcc_stOre and the amount of coverage COV_B with respect to polygon B for each pixel of the merge pixel layer ML being covered less than 100 percent by the polygon B only are stored in the merge buffer MB (Fig. 5)

The procedure for the pixels of the merge pixel layer ML₁ which are covered not only by the second polygon B but also by the first polygon A, should be discussed in the following. If a total amount of coverage cov_tot (which is, in this case, the sum of the amount of coverage COV_A of polygon A and the amount of coverage COV_B of polygon B) of a pixel by the covering polygons A, B is less than 100 percent, the partial color contribution pec store and the amount of coverage COV_B of the second polygon B are simply accumulated to the partial color contribution pcc_stOre and the amount of coverage cov_stOre being already stored for this pixel of the merge pixel layer ML.

If the total amount of coverage cov_tot is equal to or exceeds 100 percent, the partial color contribution pec of the second polygon B is accumulated to the partial color contribution pcc_stOre already stored for each pixel of the merge pixel layer ML only up to 100 percent of total coverage cov_tot, wherein the rest of the partial color contribution pec of the polygon B exceeding 100 percent of total coverage is cutted. Thus, when the accumulated coverage is 100 percent or more, the associated color values are accumulated, but such that the partial color contribution pec is proportional to the coverage contribution up to 100 percent. For example, if the accumulated coverage will hit 100 percent and there was only room to add 30 percent of the current pixels coverage, then also only 30 percent of the current pixel color contribution will be accumulated to the stored partial color contribution pcCstore in the merge pixel layer ML.

However, it is also possible to cut off a portion of the stored partial color contribution pcc_stOre proportional to the amount of coverage to be accumulated exceeding 100% of the total amount of coverage cov_tot and to add the partial color contribution pec of polygon B with the remaining portion of the stored partial color contribution pcc_stOre (which is, in this case, the partial color contribution of polygon A). After obtaining a pixel color pc by calculating the accumulated partial color contributions of the associated polygons A and B, the according pixel is allocated to the display pixel layer DL from the merge pixel layer ML and the associated pixel position in the merge layer is reset, e.g. the value is put to black.

Fig. 4C shows a diagram for illustrating the rendering process of a third polygon C to a N^th polygon D. After rendering of the polygon B as shown in Fig. 4B, a third polygon C (in case N is bigger than 2, which is almost always the case) and a forth polygon D (for the sake of illustration, the number of polygons N is equal four) are rendered in an analogous way as described in the rendering procedure of the polygon B. However, after performing rendering of the according polygons A to D, there are still remaining pixels of the merge pixel layer ML, which represent a border edge of all rendered polygons. These pixels are anti-aliased in the same method as described with respect to Fig. IA, to achieve an anti- aliased border edge of the associated polygons.

Thus, since the edge anti-aliasing technique as described in Fig. IA is performed only for the remaining pixels of the merge pixel layer ML after rendering all associated polygons A to D, a color shine through between adjacent surfaces in the display pixel layer DL is avoided, since no background color has been used in the computation of the blended pixel values at adjacent surfaces of the rendered polygons.

However, in case of an overlapping of the according polygons, an error is introduced but not on adjacent edges. Herein, the error will be on the edge of a polygon, that occludes another polygon exactly, since the occluded polygon still contributes color to a pixel overlapping the polygon edge, because the colors are merged no geometrical data is taken into consideration to avoid the contribution of the occluded pixel part to the merge pixel layer ML.

In the following, the procedure according to a second embodiment of the method of the present invention should be explained.

As discussed above, the problem of color shine-through can occur either where two polygonal graphics primitives overlap one another or where they abut perfectly so that they share a common border. A common border shared between independently rendered polygons would be rare in general, since the probability of edges of two arbitrary, different polygons aligning perfectly is very low. However, in practice, the multiple polygons being rendered are often parts of a larger, more complex polygon. That is, a composite polygon is rendered as a set of tessellated primitive polygons. In this case, each of the primitive polygons will share a border with at least one other.

The second embodiment of the invention addresses the problem of color-shine through for composite rendering of this kind. Because of the tessellation of the primitive polygons, it is known in advance that the coverage values for pixels anywhere in the interior of the composite will sum to 100%. This fact is exploited in the second embodiment, but the method is otherwise very similar to the first embodiment. In this second embodiment the accumulated amount of contribution value for each pixel is stored, while each polygon is rendered. There is no need to test each pixel to determine when the total coverage or contribution reaches or exceeds 100%, and no need to move pixels to the display layer from the merge layer as they reach this threshold. Pixels at the outer edges of the composite primitive may have less than full contribution (that is, less than 100%). However, this can be accommodated provided that the pixels include a contribution channel. The accumulated contribution channel values are used to correctly blend the composite primitive into the frame buffer such that the pixels at the outer edges are anti-aliased in the proper way. The contribution channel stored in the composite primitive buffer is called con_cpb in the pseudo code below.

The method of this embodiment therefore consists of two stages. In the first stage, for each polygon, the partial color contributions and contribution values for each pixel are cumulatively summed in a composite primitive merge buffer. (This is the same as the merge buffer of the first embodiment). In pseudo-code, for example, the following routine can be called for every pixel within a primitive:

writePixel_cpb( x, y, a_frag, r_frag, g_frag, b_frag, con_frag )

{ con_cpb[y][x] = con frag + con_cpb[y][x]; a_cpb[y][x] = a_frag + a_cpb[y][x]; r_cpb[y][x] = r_frag + r_cpb[y][x]; g_cpb[y][x] = g_frag + g_cpb[y][x]; b_cpb[y][x] = b_frag + b_cpb[y][x];

}

Here, the pixels are assumed to be RGBA pixels with an additional field storing the contribution. Contribution is a more general term for coverage, as will be discussed further below. Thus, con frag is the contribution of the current polygon to the current pixel and con_cpb[y][x] is the stored accumulated contribution over the various polygons of the composite primitive. The alpha channel is used to accommodate standard pixel blending functions, in the conventional manner. Thus, the blending required for correct anti-aliasing is achieved independently of any conventional pixel blending. Note that the same blending mode will be used for all polygons in the same composite primitive.

The writePixel cpbQ routine adds the current pixel fragment (frag) color components to those in the composite primitive merge buffer (cpb). In this example, each partial color contribution value for the pixel fragment has been pre-multiplied (implicitly multiplied) by its respective polygon-contribution value, so that the values accumulated in the merge buffer are implicitly weighted by contribution.

Note that it is no problem if the composite primitive actually consists of only a single primitive. Nonetheless, if such isolated primitives can be identified as such, it will in general be more efficient to blend them directly into frame buffer, rather than process them via the composite primitive buffer.

When the accumulation into the merge buffer has been completed for all of the component polygons, the "partial" color contribution values in the interior of the composite primitive correspond to a contribution value of 100%. This is true for the pixels in the interior of individual polygons (which will have received a full contribution from a single polygon); and for pixels that lie on the internal borders between polygons (which will have partial contributions from the polygons on respective sides of the border). In other words, at the internal borders partial pixel values from one polygon will be complemented by the partial pixel values from any adjacent polygon(s). As noted above, edge pixels on the outer boundary of the composite primitive may have less than 100% contribution.

After the final primitive of the composite primitive has been accumulated to the composite merge buffer, the application or middleware issues an additional function call to the graphics sub-system. In response to this call, the composite merge buffer is read and the data blended into the display buffer or frame buffer according to the anti-aliasing blending which is proportional to the cpb stored contribution value. If a conventional pixel blending function is also to be applied (based on the accumulated values of alpha) then this blending should be performed before application of the anti-aliasing blending. The following pseudo-code function is one possible example of this anti-aliasing blending:

blend CPB into FBO

{ do for all pixels in Composite Primitive merge Buffer

{ contrlmin = 1.0 - con_cpb[y][x]; a_fb[y][x] = CLIP( a_cpb[y][x] + (contrlmin * a_fb[y][x]) , 0.0, 1.0 ); r_fb[y][x] = CLIP( r_cpb[y][x] + (contrlmin * r_fb[y][x]) , 0.0, 1.0 ); g_fb[y][x] = CLIP( g_cpb[y][x] + (contrlmin * g_fb[y][x]) , 0.0, 1.0 ); b_fb[y][x] = CLIP( b_cpb[y][x] + (contrlmin * b_fb[y][x]) , 0.0, 1.0 );

} }

Here, the various color channel values (R, G, B, A) in the frame buffer (fb) are blended with the corresponding values stored in the composite primitive merge buffer (cpb). Note that the values from the merge buffer are already implicitly weighted and so all that is necessary is to weight the frame buffer values by the complement of the contribution value stored in the merge buffer. This is the variable "contrlmin" in the pseudo-code above, which is defined as 1.0 minus the merge buffer contribution value for the current pixel.

Note that the CLIP operation is only needed if contribution values can become negative or more than 1.0. This could be the case when using convolution filtering where the filter profile has negative lobes.

This second embodiment can be implemented easily in a graphics API. For example, using OpenGL ES 1.0. In the OpenGL ES API the Draw Arrays and DrawElements, when called by the application (or middle ware), issue a sequence of primitives to the graphics rendering system. The present embodiment adds two extra methods to indicate the start and end of a composite primitive, as an extension to the basic API. The first method allows the programmer to explicitly indicate the start of a composite primitive and the second method allows the programmer to indicate the end. For instance, function calls similar to the following could be used:

CPrimMarkerBegin

{

[Function calls to draw individual polygons of the composite primitive]

} CPrimMarkerEnd In this way several DrawArrays (and DrawElements) calls can be used to construct a single composite primitive.

An alternative implementation, which may be easier for the programmer, is as follows. This implementation may be especially appropriate for applying the method of the invention to pre-existing Open GL source code, since the way the code is written may not need to change. That is, this implementation may be more easily backward-compatible with legacy code.

This implementation changes the way that the function calls for drawing primitives are interpreted. A flag is set to inform the graphics system that every call to DrawArrays or DrawElements should be interpreted as being a single composite primitive. Thus, when enabled, each of a plurality of primitives drawn within each DrawArrays or DrawElements function call will be drawn as a composite primitive as described above. This corresponds to the way the calls are already being used by the programmer, in many cases. Setting the state can be done with function calls similar to the following:

Enable/Disable (DRAWARRAYS IS COMPOSITE PRIMITIVE) Enable/Disable (DRAWELEMENTS IS COMPOSITE PRIMITIVE)

Preferably these special modes are disabled by default and the application programmer can enable them as desired. This should reduce the potential for unexpected behaviour, if the programmer is not aware of the drawing mode.

Note that if the programmer has used a single DrawArrays or DrawElements call to draw multiple composite primitives, the resulting behaviour may be undesirable. For example, a if a group of overlapping primitives is drawn, the assumptions made in the second embodiment of the invention - that each interior pixel has 100% total coverage - would be broken. This may result, for example, in clipping of color values incorrectly. This usage of DrawArrays or DrawElements is generally very unlikely. However it should be avoided altogether: instead, the application programmer should split the DrawArrays or DrawElements calls such that they contain a single composite primitive, matching the assumption of non-overlapping coverage of the drawing space.

Although the foregoing implementations have been described with reference to the OpenGL ES API, the skilled person will readily appreciate that similar implementations are possible with similar modifications to other known graphics APIs. Fig. 5 is a block diagram of a vector graphics processor of the present invention, which is adapted to execute a method according to either embodiment of the present invention. The vector graphics processor comprises a 2D vector graphics pipeline, in which a graphics geometry is rendered polygon per polygon, wherein the pixels of each rendered polygon are buffered in a frame buffer FB that is used by a display at the end of the 2D vector graphics pipeline. The 2D vector graphics pipeline as shown in Fig. 5 is based on a common openVG pipeline, wherein the adaption of this pipeline for performing the method of the present invention should be discussed in the following.

At the beginning of the 2D vector graphics pipeline, a path, transformation, stroke and paint unit PTSP is provided. In this unit the application defines the path to be drawn, and sets any transformation, stroke and paint parameters. This parameters include transformation matrices, stroke line width, stroke paint color, fill paint color, and comparable parameters. If the path is to be both filled and stroked, the remainder of the pipeline may be invoked twice in a serialized fashion, first to fill and then to stroke the path.

At the output of the path, transformation, stroke and paint unit PTSP, a stroked path generation unit SPG is connected for further processing the graphics geometry to be rendered. Herein, if the path is to be stroked, the stroke parameters are applied to generate a new path that describes the stroked geometry. Typically, the input path is offset by using the fixed stroke width, to generate the stroked path.

After the stroked path generation unit SPG, a transformation unit TF is provided in which geometric entities defined in the user coordinate system are transformed into the screen coordinate system. These coordinate transformations are performed by matrix and matrix- vector multiplications.

The next stage of the vector graphics pipeline is the rasterizer RAST. At this stage of processing the geometric information is converted to bitmap data. If an anti-aliasing feature is disabled, only pixel centers are sampled.

However, if edge anti-aliasing is enabled, the rasterizer RAST is provided to determine a footprint of an according polygon or path and to determine an amount of coverage of each pixel (which could be, as already mentioned above, a pixel square or a prefϊlter footprint) being at least partially covered by an according polygon. In addition, the partial pixel color pec (cf. Fig. 4A to Fig. 4C) could also be computed in the rasterizer RAST.

After the rasterizer RAST, a clipping and masking unit CM is provided in which pixels not lying within the bounds of the drawing surfaces and scissor rectangles are eliminated from the pipeline. In addition, application-specified alpha mask values are also applied to remove pixels with zero alpha values.

After the clipping and masking unit CM, a paint generation unit PG is provided in which the relevant current paint is applied to each pixel of the drawing surface, to finally calculate its color and alpha values. Thereafter, optionally an image interpolation unit IP is embedded, in which the color and alpha values are calculated at each pixel using the inverse of the current image matrix, if an image is drawn. Otherwise, the results from the preceding stage are passed through unchanged.

The last stage of the vector graphics pipeline before the frame buffer FB is the blending and anti-aliasing unit BA, in which at each pixel, the source color and alpha values are blended with the corresponding destination color and alpha values according to the current blending rule. The computed coverage values are used to finally produce anti-aliased images.

Herein, the blending and anti-aliasing unit BA is adapted to calculate the pixel color pc in accordance with the method of the present invention. A merge buffer MB is provided to buffer the merge pixel layer ML containing data of partial color contribution pccstore and (where necessary) the amount of coverage cov_stOre. In addition, a display buffer DB is provided to buffer the display pixel layer DL containing pixel color data pc. Both buffers MB and DB are connected to the blending and anti-aliasing unit BA, in which the accumulating of partial color contribution pec according to the method of the present invention is performed. For the merge buffer MB and the display buffer DB, a read-modify- write to memory might be used. A write cache, or an otherwise controlled on-chip buffer might be a further preferred solution for implementing the according buffers. The two layers of merge pixel layer ML and the display pixel layer DL could be of full frame size or a small part of it, to keep it on a chip, or even implemented in a write cache organization. In the diagram of Fig. 5, the two buffers MB and DB could be implemented in an RGBA buffer block or it can be a small buffer or cache within the blending and anti-aliasing block BA. The edge anti-aliased polygons from the blending and anti-aliasing unit BA are finally written into a frame buffer FB for displaying the rendered image of the graphics geometry.

The vector graphics processor has been described with regard to a 2D vector graphics pipeline. It is, however, possible to implement the same pixel coverage edge antialiasing method of the present invention in a 3D graphics pipeline. Herein, when a Z-buffer is enabled, a known technique of a fragment-buffer has to be used, however, when the Z-buffer is disabled, the two-layer approach of the edge anti-aliasing method of the present invention becomes applicable.

Fig. 6 shows a computer comprising the vector graphics system of the present invention. The computer PC comprises a processor 3, a graphics adapter 2 and a memory 4. The processor 3 is suitably programmed to supply input data IT to the graphics adapter 2. The processor 3 communicates with the memory 4 via the bus Dl. The graphics adapter 2 comprises the vector graphics system 1. Usually, the graphics adapter is a module that is plugged into a suitable slot (for example an AGP slot). Usually, the graphics adapter 2 comprises its own memory (for example the frame buffer FB). However, the graphics adapter 2 may use part of the memory 4 of the computer PC, now the graphics adapter need to communicate with the memory 4 via the bus D2 or via the processor 3 and the bus Dl. The graphics adapter 2 supplies the output image OI via a standard interface to the display apparatus DA. The display apparatus DA may be any suitable display, such as, for example, a cathode ray tube, a liquid crystal display, or any other matrix display. The computer PC and the display DA need not be separate units which communicate via a standard interface but may be combined in a single apparatus, such as, for example, a personal digital assistant (PDA or pocket PC) or any other mobile device with a display for displaying images.

Fig. 7 shows a display apparatus DA comprising the vector graphics system of the present invention. The display apparatus DA comprises the pipeline 1, which receives the input data (geometry plus related data) IT and supplies the output image OI to a signal processing circuit 11. The signal processing circuit 11 processes the output image OI to obtain a drive signal DS for the display 12.

For clarity, the present embodiments have been described using the assumption of a simple pixel pre-filter which is a block filter on a unit square in the pixel grid. This results in non-overlapping, complete coverage of the image area. In this case, the "contribution" or overlap of a polygon with a pre-fϊlter is simply equal to the "coverage" of the pixel square in question by that polygon. That is, the "coverage" is one specific example of a broader class of "contribution" by a polygon to a pixel. However, as the skilled person will readily appreciate (and as mentioned previously above), in the second embodiment, it is not essential that such a simple pre-filter is used. In particular, larger pre-filter functions are known and may be beneficial. In this way the pre-filters of different pixels may overlap. Also, instead of a uniform box-filter, a more complex weighting function may be used to determine the contribution - for example, such that the influence of a polygon decreases with increasing distance from the pixel in question. Such weighting functions may include negative lobes (negative weights). Therefore, in general the value of a contribution may be positive or negative. As will be apparent to the skilled person, all of these possibilities are within the scope of the general term "contribution", as used in the present description and claims. The adaptation of the specifically described embodiments for use with the various weighting functions mentioned will also be within the capabilities of the skilled person.

Claims

CLAIMS:

1. A method of edge anti-aliasing a graphics geometry having N polygons (A, B, C, D), each polygon having a color, the method comprising the steps of: (a) determining a footprint of one of the N polygons by allocating all pixels being at least partially covered by the according polygon to a merge pixel layer (ML) in a merge buffer (MB),

(b) determining an amount of contribution (cov) to each pixel by the according polygon, (c) accumulating a partial color contribution (pec) from said polygon to a stored partial color contribution (pcc_stOre) stored for each pixel of the merge pixel layer (ML) in the merge buffer (MB) and accumulating the amount of contribution to a stored amount of contribution (cov_stOre) stored for each said pixel, the partial color contribution being based on the amount of contribution to the corresponding pixel and the color of the polygon, repeating steps (a) to (c) for all of the N polygons, and determining pixel colors (pc) of pixels in a display buffer (DB) by blending pixels of the merge buffer (MB) into the associated pixels of the display buffer (DB), wherein the pixels are blended proportionally to the accumulated stored amount of contribution (covstore) for each pixel.

2. A method as claimed in claim 1, wherein the N polygons together form a composite polygon and wherein the pixels of the merge buffer (MB) are blended into the associated pixels of the display buffer (DB) proportionally to the accumulated stored amount of contribution (cOVstore), after steps (a) to (c) have been repeated for all of the N polygons.

3. A method as claimed in claim 1, wherein the amount of contribution to each pixel by a given polygon comprises the amount of coverage by that polygon of a footprint surrounding the pixel, and wherein, in the step (c) of accumulating the partial color contribution and the amount of coverage, a portion of the partial color contribution (pec) proportional to the amount of coverage (cov) to be accumulated exceeding 100% of the total amount of coverage

(covtot) is cut off and the remaining portion of the partial color contribution (pec) to be accumulated is added with the stored partial color contribution (pcc_stOre), and stored in the merge buffer (MB) as the new partial color (pcc_stOre) value, the method further comprising:

(d) storing an accumulated pixel color (pc) of each pixel having a total coverage (cov_tot) equal to or more than 100% and allocating these pixels to the display pixel layer (DL) in a display buffer (DB), while clearing the associated pixels in the merge display layer (ML) in the merge buffer (MB),

(e) when repeating steps (a) to (c) for all of the N polygons, also repeating step (d), and

(f) determining a pixel color (pc) of pixels in the display buffer (DB) after rendering the N^th polygon (D) by blending all remaining pixels of the merge buffer (MB) proportionally to their accumulated stored amount of coverage (cov_stOre) into the associated pixels of the display buffer (DB).

4. A method as claimed in claim 1, wherein the amount of contribution to each pixel by a given polygon comprises the amount of coverage by that polygon of a footprint surrounding the pixel, and wherein, in the step (c) of accumulating the partial color contribution and the amount of coverage, a portion of the stored partial color contribution (pcc_stOre) proportional to the amount of coverage (cov) to be accumulated exceeding 100% of the total amount of coverage (cov_tot) is cut off and the partial color contribution (pec) is added with the remaining portion of the stored partial color contribution (pcc_stOre), and stored in the merge buffer (MB) as the new partial color (pcc_stOre) value, the method further comprising:

(e) when repeating steps (a) to (c) for all of the N polygons, also repeating step (d), and (f) determining a pixel color (pc) of pixels in the display buffer (DB) after rendering the N^th polygon (D) by blending all remaining pixels of the merge buffer (MB) proportionally to their accumulated stored amount of coverage (cov_stOre) into the associated pixels of the display buffer (DB).

5. A method as claimed in any of claims 1 to 4, wherein the partial color contribution (pec) is equal to the amount of contribution (cov) times the color value of the according polygon.

6. A method as claimed in claim 2, wherein the amount of contribution is an exact computation or an approximation of the overlap of a pixel's footprint with the polygon.

7. A method as claimed in claim 6, wherein the pixel's footprint is rectangular or circular.

8. A method as claimed in claim 7, wherein the area of overlap of the pixel's footprint with the polygon's footprint is weighted according to a filter function.

9. A method as claimed in one of the claims 5 to 8, wherein the color value consists o f a RGB A- value .

10. A vector graphics processor for executing a method of edge anti-aliasing a graphics geometry as claimed in one of the preceding claims, comprising:

- a rasterizer (RAST) for executing method steps (a) and (b) for each of the N polygons (A, B, C, D),

- a blending and anti-aliasing unit (BA) being coupled to the rasterizer (RAST) for executing method steps (c) and (d) for each of the N polygons (A, B, C, D), and method step (f) after rendering the N^th polygon (D),

- a merge buffer (MB) being connected to the blending and anti-aliasing unit (BA) for storing a partial color contribution (pcc_stOre) and an amount of contribution (cov_stOre) for each pixel of the merge layer (ML),

- a display buffer (DB) being connected to the blending and anti-aliasing unit (BA) for storing the pixel color (pc) for each pixel of the display pixel layer (DL), and

- a frame buffer (FB) being connected to the blending and anti-aliasing unit (BA) for receiving the pixel color (pc) data.

11. A vector graphics processor as claimed in claim 10, further comprising:

- a path, transformation, stroke, and paint unit (PTSP) for defining a path to be drawn, and for setting a transformation, stroke and paint parameters, - a stroked path generation unit (SPG) being connected at its input to the output of the path, transformation, stroke, and paint unit (PTSP) for generating a stroked path by applying the stroke parameters,

- a transformation unit (TF) being connected at its input to the output of the stroked path generation unit (SPG) for executing a transformation into a screen coordinate system, and being connected at its output to the input of the rasterizer (RAST).

12. A vector graphics processor as claimed in claim 10 or 11, further comprising:

- a clipping and masking unit (CM) being connected at its input to the output of the rasterizer (RAST) for eliminating pixels not lying within the bounds of a drawing surface;

- a paint generation unit (PG) being connected at its input to the output of the clipping and masking unit (CM) for defining a color and an alpha value at each pixel of the drawing surface; and

- an image interpolation unit (IP) being connected at its input to the output of the paint generation unit (PG) for interpolating at each pixel a color and alpha value, and being connect at its output to the input of the blending and anti-aliasing unit (BA).

13. A graphics adapter comprising the vector graphics processor as claimed in one of the claims 10 to 12.

14. A computer comprising the vector graphics processor as claimed in one of the claims 10 to 12.

15. A display apparatus comprising the vector graphics processor as claimed in one of the claims 10 to 12.