Abstract:
The invention relates to a method, a device, a system and a software program product for determining for a pixel a coverage mask reflecting an orientation and possibly a distance from the pixel center of an original edge vector. The pixel is to be employed for displaying at least a part of a geometric primitive on a display, and the original edge vector represents an oriented edge of the geometric primitive. The method comprises as a first step determining one of four quadrants of a Cartesian coordinate system to which the original edge vector belongs due to its orientation. The original edge vector is then transposed into a predetermined one of the four quadrants. Next, a stored coverage mask is fetched, which is associated at least indirectly to the transposed edge vector. Finally, the fetched coverage mask is transformed to the quadrant to which the original edge vector belongs.

Description:
FIELD OF THE INVENTION  
         [0001]    The invention relates to a method for determining for a pixel a coverage mask reflecting an orientation, and preferably as well a distance from the pixel center, of an original edge vector. The pixel is to be employed for displaying at least a part of a geometric primitive on a display, and the original edge vector represents an oriented edge of the geometric primitive. The invention relates equally to a device, a system and a software program product for determining such a coverage mask.  
         BACKGROUND OF THE INVENTION  
         [0002]    In computer graphics, images are displayed on a screen by a discrete grid of pixels. Each pixel represents a dot on the screen. Precisely defined geometric primitives from the continuous object space, like triangles, which are to be displayed on the screen thus have to be rasterized to pixel values. This process involves finding the pixels that are at least partially covered by the primitive and defining the color of the pixels. If a pixel is only partly covered by a primitive, a special approach is required for determining an appropriate color of the pixel. Since in this case, the pixel has at least two primitives that cover it, the color of the pixel has to be an interpolation of the colors of the primitives in the area of the continuous object space represented by this pixel. If this process is not carried out properly, the resulting image suffers from aliasing.  
           [0003]    The aliasing phenomenon thus results from the masquerading of high spatial frequencies of the object space as low frequencies in the reconstructed image of the object space on the screen. The aliasing phenomenon creates undesirable visual artifacts known as “jaggies” or “staircasing” effect for the edges of the primitive, resulting in imprecise edges, as “popping” effect for very small primitives which are moving across the screen, or as a “flickering” of the presented image.  
           [0004]    In order eliminate the aliasing phenomenon to a certain extent, antialiasing techniques are employed. It is to be noted that a total elimination is not theoretically possible.  
           [0005]    Antialiasing techniques are essential for high-quality graphics, and they are endorsed by technical standards like OpenGL and DirectX-Direct3D® by Microsoft®. Antialiasing is of particular importance for products including 3D (three-dimensional) graphics and having a “mid-size” display, i.e. a display resolution less than e.g. VGA (Video Graphics Array) but more than QQVGA (Quarter Quarter VGA). Moreover, an efficient and low-power implementation of antialiasing in a display larger than QQVGA typically requires a hardware acceleration. This is important, for instance, for mobile devices.  
           [0006]    The causes of aliasing in computer generated imagery are well known from the signal sampling theory and may be broken into two components. The first component is an aliasing due to inadequate sampling of the geometrical primitive from the continuous object space. The second component is an aliasing due to an incorrect or inadequate reconstruction of the displayed image from the generated samples.  
           [0007]    While many antialiasing techniques have been proposed, there are no practical effective solutions to succeed in removing both aliasing components causes at once. Therefore, the practical schemes for antialiasing can be classified in pre- and post-filtering methods.  
           [0008]    In the post-filtering antialiasing methods, which are also referred to as supersampling antialiasing methods, the geometric primitives in the continuous object space are point sampled at a higher rate than can be displayed, i.e. with multiple samples per pixel. These samples are then numerically filtered by a discrete digital filter for a resampling at the display resolution. The post-filtering hardware algorithms have increased computation and storage costs due to the multiple sample approach. Moreover, they result in certain situations in image artifacts due to the inadequate sampling rate, since the continuous object space often contains infinite spatial frequencies.  
           [0009]    The pre-filtering antialiasing methods, which are also referred to as area sampling antialiasing methods, generate displayed images of a higher quality involving potentially lower hardware costs than post-filtering methods by storing only one sample per pixel. The pre-filtering antialiasing methods remove the high frequency components that would produce aliasing from the image before display by performing a low-pass filtering in a pre-filter stage. The bandwidth limited image is then point sampled at the display resolution to produce images with reduced aliasing. The pre-filtering of a geometric primitive is performed by determining pixel coverage values that are used to weight or smooth pixel colors computed during the sampling. Practical schemes of antialiasing with pre-filtering rely heavily on pre-computed coverage mask lookup tables. Those tables are indexed by parameters that contain information about the distance from the pixel center to the edge of the geometrical primitive, information about the slope of the edge, and information on the possible orientation of the edges. To each index, a coverage mask is associated, which gives an information on the extent to which the pixel is covered by the primitive and which thus allows to weight the pixel colors accordingly.  
           [0010]    The antialiasing with pre-filtering is performed during a primitive rasterization time. Simply speaking, the primitive rasterization is the conversion through interpolation from the description of the primitive with two-dimensional vertices in the continuous object space into a sequence of properly shaded pixels on the display that belong to the interior and to the boundary edges of the primitive. If a pixel is found to lie on the border of the primitive, the antialiasing is performed at this time by weighting the color of the pixel with the coverage value of the pixel, in order to smooth the edge. Therefore, the method chosen for primitive rasterization will impose limitations on the type of a pre-filtering antialiasing algorithm that can be efficiently implemented in hardware in conjunction with the rasterization engine.  
           [0011]    For illustration, different hardware solutions for rasterization approaches and suitable antialiasing schemes based on pre-filtering will be described in the following. The geometric primitive to be displayed is assumed to be a triangle.  
           [0012]    A first type of solution is given by the traditional triangle rasterization and antialiasing.  
           [0013]    A traditional triangle rasterization, which is also referred to as triangle scan-conversion, is typically performed by an algorithm consisting of an edge-walking interpolation phase followed by a span interpolation phase in its inner loop. During the edge-walking phase, the triangle is scanned vertically from top to bottom, sequentially delivering for every intercepted display scan-line the triangle boundaries along the two edges visited at a particular time. The triangle boundaries constitute the start and the end of the span interpolation phase. During the edge-walking phase, the edge interpolation is performed using the Bresenham&#39;s line algorithm. In Bresenham&#39;s line algorithm, the sign bit of a control parameter, which can be computed incrementally, determines the respective next pixel that constitutes the best approximation for the ideal line that has to be drawn by the algorithm. The respectively determined next pixel is output on the screen as part of the drawn line.  
           [0014]    Hardware antialiasing algorithms with pre-filtering that are working in conjunction with this traditional triangle scan conversion method have focused on modifying the Bresenham&#39;s line algorithm to incorporate an area sampling.  
           [0015]    M. L. V. Pitteway and D. Watkinson, for example, propose in the document “Bresenham&#39;s Algorithm with Grey Scale”, Communications of the ACM, vol. 23, no. 11, pp. 625-626, November 1980, modifications which allow to interpret the control parameter value as a distance measure from the pixel drawn as part of the rasterized line to the ideal line, and to use this control parameter value to weight the color of the pixel that will be displayed. The main drawback of this approach relates to the fact that it cannot handle line ends properly.  
           [0016]    Another version of the Bresenham&#39;s line algorithm with antialiasing capabilities that can be used to smooth triangle&#39;s edges has been described by S. Gupta and R. F. Sproull in the document “Filtering Edges for Gray-Scale Displays”, Computer Graphics (SIGGRAPH 81 Conference Proceedings), vol. 15, no. 3, pp. 1-5, August 1981. Here, the ideal line is convolved with a circularly symmetric filter. The convolution operation is implemented with a lookup table, which is indexed by the perpendicular distance from the pixel center to the line center. Analytic expressions for line ends are again difficult to derive, and a separate, more complex indexing scheme is required for that with less precise two-dimensional lookup tables. The computational complexity increases further, when the antialiasing of the triangle&#39;s vertices, i.e. of the points where two line ends will intersect, or the antialiasing of triangles smaller than a pixel, i.e. where multiple line ends and vertices exist, are considered making the traditional approach of rasterization less attractive when used in conjunction with the antialiasing algorithms based on pre-filtering.  
           [0017]    It is a drawback of the antialiasing algorithms with pre-filtering based on the traditional rasterization method that it is difficult to achieve an accurate antialiasing of the triangle corners and that it is computationally expensive. It is also a drawback of this approach that the triangle traversal order is imposed by the scan conversion algorithm. The triangle is scanned vertically from top to bottom, and for each generated span, all fragments between the span ends are interpolated before the fragments on other spans can be generated. This makes it very difficult to generate several fragments in parallel in a random order and it makes implementations impossible that generate fragments in a tile rasterization order. Several studies of texture caches have shown the benefits of using a tile rasterization order, in which the screen is tiled into rectangles that are related to the size of the texture cache. All fragments within one tile are generated before any fragments within another tile. Similarly, most frame buffers physically tile the screen into rectangular pages, and tiled rasterization that respects these page boundaries allows for fewer page crossings that can be more efficiently prefetched. The traditional rasterization methods are not capable to make efficient usage of such hardware organizations.  
           [0018]    A second type of solution for rasterization and antialiasing based on pre-filtering is given by a triangle rasterization with edge functions and antialiasing.  
           [0019]    In this type of solution, the triangle rasterization is based on an algebraic representation of the edges of the triangle. The edge of a triangle can be represented as a vector between its respective vertices, in case respectively one vertex is considered as the source and another vertex as the sink of the vector. This is illustrated in FIG. 1 a , in which one vertex of a triangle edge is shown as a first dot at a position (x A ,y A ) in a Cartesian coordinate system, and in which another vertex of a triangle edge is shown as a second dot at a position (x A +Δx, y A +Δy) in the Cartesian coordinate system. Δx represents the distance in x-direction between the first dot and the second dot, while Δy represents the distance in y-direction between the first dot and the second dot. An arrow V connecting the first dot with the second dot constitutes the vector which represents the triangle edge. The edge is thus defined by a vector starting at point (x A ,y A ) and having the slope Δy/Δx.  
           [0020]    When proceeding from such an edge vector, it can be detected whether a current rasterization position (x M ,y M ) in the screen space lies in one of the half-planes “left side” or “right side” delimited by the edge vector V or exactly on the edge vector V. The detection process involves the computation of the cross-product of the edge vector V with a vector formed by the edge vector&#39;s source (x A ,y A ) and the current rasterization position (x M ,y M ). This cross-product can be expressed for any arbitrary pixel position (x,y) on the screen as an analytical function, called the edge function, with the unknowns (x,y). If the result of an evaluation of the edge function at the current rasterization position (x M ,y M ) is zero, the position (x M ,y M ) lies exactly on the edge defined by edge vector V. Otherwise, depending on the sign of the evaluation&#39;s result, the position (x M ,y M ) lies in one of the half-planes delimited by the edge vector V.  
           [0021]    When considering a triangle described by its clockwise or counter-clockwise oriented edge vectors, a position belongs to the interior of the triangle, if all its edge functions computed for this position and the three edge vectors have the same sign. This is illustrated in FIG. 1 b  for a triangle having the vertices A, B and C. The interior of the triangle is formed by the union of the right sides of the oriented edges AB, BC and CA represented by a respective edge vector V 1 , V 2  and V 3 . A plus sign is associated to the interior of the triangle and a minus sign is associated to the planes delimited by the edge vector V 1 , V 2  and V 3  and lying outside of the triangle. The values for the edge functions are used as a “stencil” that allows to modify the color of a pixel only if it is interior to the triangle. Thus, the process of rasterizing the triangle can then be reduced to an algorithm that traverses an arbitrary area that includes the interior of the triangle, and that does not strictly follow the outline of the triangle as in the case of the traditional scan conversion rasterization method.  
           [0022]    Additionally, if the edge function is properly normalized, its evaluation yields the distance from the respective edge vector to the pixel position (x,y), and this distance can be used in determining the coverage of the pixel at position (x,y) by the triangle&#39;s edge. This means that the normalized edge function can be employed for both, rasterization and antialiasing.  
           [0023]    The operating principle of an antialiasing algorithm with edge functions is illustrated in more detail in FIGS. 2 a ,  2   b  and  2   c.    
           [0024]    [0024]FIG. 2 a  illustrates a 16-bit coverage mask encoding scheme. On the left hand side of FIG. 2 a , the sequence of the 16 bits of the coverage or subpixel mask is represented by a sequence of 16 squares m 0 -m 15 . Each of the bits represents a binary value for a subpixel of a two-dimensional 4×4 grid of subpixels. A corresponding 4×4 grid  10  of subpixels, which are associated to the area of a pixel, is shown on the right hand side of FIG. 2 a . Each of the subpixels can be individually lit and unlit by setting the corresponding bit m 0 -m 15  accordingly. In hardware implementations for antialiasing with normalized edge functions, such pictorial representations of the pixel coverage coded in coverage masks are pre-computed for various distances of an edge to the pixel center and various angles of an edge. The pre-computed coverage masks are stored in a coverage mask lookup table.  
           [0025]    [0025]FIG. 2 b  illustrates the fetching of a stored coverage mask from a lookup table. On the left hand side of FIG. 2 b , the area  11  of a pixel on a screen is depicted, with an edge vector V passing through this area  11 . In the middle of FIG. 2 b , a look up table LUT  12  is depicted, and on the right hand side of FIG. 2 b , a coverage mask  13  is depicted in form of a 4×4 grid of subpixels. During rasterization, the normalized edge function computed for the current rasterization position (x M ,y M ) is interpreted as a distance d of the edge vector V from the pixel center M. The distance d is used together with the edge slope α as a lookup table address to fetch the 16-bit coverage mask  13  of the current rasterization position for that edge. In the depicted coverage mask  13 , black squares represent a bit value of “1” of a respective subpixel, while white squares represent a bit value of “0” of a respective subpixel.  
           [0026]    [0026]FIG. 2 c  illustrates the determination of a final coverage value for a pixel using box filtering by ANDing the coverage masks for three edge vectors of a triangle. A first square  14  represents the pixel area which is partly covered by a triangle  15 . The table lookup described with reference to FIG. 2 b  is performed for all the three edges of the triangle  15 , resulting in three distinct coverage masks  16 ,  17  and  18 . Each of the coverage masks  16 ,  17  and  18  is represented in FIG. 2 c  in form of a 4×4 grid of subpixels. The three resulting coverage masks  16 ,  17  and  18  are then logically combined by an AND operation to produce a final coverage mask  19 . The final coverage mask  19  represents the extent to which the pixel at the current rasterization position (x M , y M ) is covered by the triangle. From the number of lit subpixels out of the total number of subpixels represented in the final coverage mask  19 , the fraction of the pixel covered by the triangle can be computed. In the presented example, 6 of the 16 bits have a value of 11111 and are thus considered to be lit, which results in a coverage value of {fraction (6/16)}.  
           [0027]    The resulting coverage value is used to modulate the color of the pixel, i.e. the transparency or the alpha value, which is computed by interpolation for the current rasterization position (x M ,y M )  
           [0028]    The scheme presented in FIG. 2 c  is equivalent with a process of pre-filtering having a box-shaped filter kernel.  
           [0029]    The rasterization and antialiasing method presented with reference to FIGS. 2 a  to  2   c  was adopted by H. Fuchs et al. in document “Fast Spheres, Shadows, Textures, Transparencies, and Image Enhancements in Pixel-Planes”, Computer Graphics (SIGGRAPH  85  Conference Proceedings), vol. 19, no. 3, pp. 111-120, July 1985 in Pixel Planes. Pixel Planes is a logic-enhanced memory system for raster graphics and imaging with a high degree of generality. Using a global computing structure, more specifically a linear expression tree evaluated in a bit-sequential order, the system can evaluate linear expressions like edge functions for every pixel position (x,y) on the screen in parallel. The coverage mask for an edge is fetched by indexing a pre-computed coverage mask lookup table with the normalized edge function value and one of the coefficients of the edge function that gives information about the slope of the edge. The system is extremely large, since it provides a separate processor for every pixel in the display. Each of the pixel processors contains an 1-bit ALU (arithmetic-logic unit) and a small amount of memory. Pixel-Planes 4, a full-scale system completed in 1986, contained 262144 processors forming a 512-by-512 pixel image.  
           [0030]    In the document “A Parallel Algorithm for Polygon Rasterization”, Computer Graphics (SIGGRAPH 88 Conference Proceedings), vol. 22, no. 4, pp. 17-20, August 1988, by J. Pineda, an effective expression for the cross-product of the vectors was embodied in the edge function formulation, emphasizing that iterative techniques, with only one addition per pixel, can be used for neighboring pixels to evaluate the edge function. For an edge vector defined by the points (x A ,y A ) and (x A +Δx,y A +Δy), as presented in FIG. 1 a , this edge function for a certain point M at position (x M ,y M ), e.g. the center M of a pixel, is expressed as:  
             E ( x   M   ,y   M )=( x   M   −x   A )·Δ y −( y   M   −y   A )·Δ x   (1)  
           [0031]    The iterative property is well suited for a low-cost rasterizer, which steps through a triangle generating one or a group of fragments at each step. By this new edge function formulation, the method of triangle rasterization of the second presented type of solution is more effective in performance and hardware costs than the traditional rasterization method presented above as first type of solution.  
           [0032]    An antialiasing algorithm using coverage masks which are based on the edge function formulation from the above cited document “A Parallel Algorithm for Polygon Rasterization” has been presented by A. Schilling in the document “A New Simple and Efficient Antialiasing with Subpixel Masks”, Computer Graphics (SIGGRAPH 91 Conference Proceedings), vol. 25, no. 4, pp. 133-141, July 1991. Each pixel is represented as a matrix of 4×4 subpixels and the associated coverage mask is encoded as a 16-bit word as presented in FIG. 2 a . A new formulation for the distance of the edge vector to the pixel center M with a good accuracy based on the edge function normalization with an L 1 -norm is proposed, which avoids the sum of squares and the square root computation involved by the Euclidian distance evaluation:  
                       d   L1          (   M   )       =       E        (       x   M     ,     y   M       )                Δ                 x          +          Δ                 y                          =         (       x   M     -     x   A       )     ·       Δ                 y              Δ                 x          +          Δ                 y                -       (       y   M     -     y   A       )     ·       Δ                 x              Δ                 x          +          Δ                 y                              =           (       x   M     -     x   A       )     ·   d                       e   x          (   α   )         -         (       y   M     -     y   A       )     ·   d                       e   y          (   α   )                       =       sgn        (       d   L1          (   M   )       )       ·   d   ·           Δ                   x   2       +     Δ                   y   2                    Δ                 x          +          Δ                 y                            =       sgn        (       d   L1          (   M   )       )       ·     f        (     d   ,   α     )                       (   2   )                               
 
           [0033]    The L 1 -norm distance d L1 (M) and the parameters de x (α) and de y (α) are functions of the Euclidian distance d and the angle α presented in FIG. 2 b.    
           [0034]    Any edge vector in the 2D (two dimensional) space at any Euclidian distance d from the pixel center M and at any angle α can be identified unambiguously using the parameters d L1 (M), de x (α) and sgn(de y (α)). Since the angle α is difficult to compute per se, the index used to fetch the coverage masks from the coverage mask lookup table can therefore be composed of the parameters d L1 (M), de x (α), and sgn(dey(α)). In a practical implementation, only the coverage masks for partially covered pixels have to be stored in the coverage mask lookup table, imposing the range for the L 1 -norm distance to be d L1 (M)ε(−0.5,+0.5).  
           [0035]    Outside this range, the pixel is totally covered or totally uncovered by the triangle edge, and the coverage mask can be assigned implicitly to comprise subpixels which are all set or unset, depending on the sign of the L 1 -norm distance d L1 (M). The ranges for the other parameters that depend on the angle α of the edge vector alone are de x (α)ε[−1,+1] and sgn(de y (α))ε={−1,+1}.  
           [0036]    In order to limit the coverage masks lookup table to a reasonable size, the edge vectors can be grouped in edge vector classes, and only several representative classes are stored in the coverage masks lookup table. An edge vector class is defined in this context as a set of all the edge vectors with the same de x (α) and sgn(de y (α)) values, but with distinct d L1 (M) values, the values lying in the above indicated ranges. Hence, an edge vector class contains all the edge vectors with the same slope that may partially cover a pixel.  
           [0037]    With a subpixel lattice of 4×4, only 32 representative edge vector classes from all four quadrants of the plane have to be stored, as illustrated in FIGS. 3 a  and  3   b.    
           [0038]    [0038]FIG. 3 a  shows an enlarged 7×7 grid of subpixels, in which the subpixels are shown as dotted squares. The 4×4 subpixels in the right upper corner of the enlarged grid represent a first quadrant for vectors of a first orientation. The 4×4 subpixels in the left upper corner of the enlarged grid represent a second quadrant for vectors of a second orientation. The 4×4 subpixels in the left lower corner of the enlarged grid represent a third quadrant for vectors of a third orientation. The 4×4 subpixels in the right lower corner of the enlarged grid represent a fourth quadrant for vectors of a fourth orientation. The middle row and the middle column of subpixels thus belong in common to respectively two of the 4×4 grids of subpixels, while the central subpixel of the enlarged grid belongs in common to all four of the 4×4 grids of subpixels. Further, 32 representative edge vector classes represented through a respective sample edge vector per class are shown, all vectors having their source at the central subpixel of the enlarged grid. Eight of the sample edge vectors are labeled A to H, respectively. The 32 representative edge vector classes were chosen by drawing all possible edge vectors that are passing through the subpixel centers of a pixel when proceeding from the center of the corner subpixels.  
           [0039]    [0039]FIG. 3 b  shows the edge vectors belonging to the representative edge vector class B, i.e. all edge vectors having the same slope as the edge vector B of FIG. 3 a  and having one of 17 possible distances d L1 (M) to the center of a 4×4 grid  20  of subpixel.  
           [0040]    Then, the coverage mask that will be stored corresponding to an index given by the parameters d L1 (M), de x (α) and sgn(de y (α)) of an edge vector is computed by ensuring that the number of subpixels lit in the coverage mask is correct plus or minus ½ of a subpixel, based on the exact covered area of the pixel.  
           [0041]    The index for an entry in the coverage masks lookup table is obtained by concatenating the truncated L 1 -norm distance d L1 (M) to 5 msb (most significant bits) including the sign bit, the truncated parameter de x (α) to 5 msb including the sign bit, and one bit for the sign of the parameter de y (α). Nevertheless, additional redundancy has to be built in the table. On the one hand, it has to be ensured that two adjacent triangles, both front-facing or both back-facing, always complement each other, i.e. a total coverage of more than 4×4 subpixels per pixel is impossible. Adjacent primitives which occupy other than 100% of the pixel lead to color errors like edge cracking. On the other hand, the biasing of a rounding scheme based on truncation towards −∞ has to be counteracted in a two&#39;s complement number system. This increases the coverage masks lookup table size to 8000 words of 16 bits comprising 8000 coverage masks.  
           [0042]    In contrast to the antialiasing methods with pre-filtering based on the traditional rasterization method, the antialiasing methods with pre-filtering based on normalized edge functions perform the antialiasing of the edge intersections with accuracy. Further, they do not favor any particular order of triangle traversal, which makes them well-suited for a tile rasterization order. However, their hardware implementation, which is based on coverage mask lookup tables, is often inefficient. The coverage mask lookup tables contain thousands of coverage masks that consume a considerable chip area. This leads to a coverage mask lookup table time-sharing access approach and prevents an employment of low-power techniques that capitalize on parallel computation to reduce the activity factor inside the antialiasing circuitry. Large lookup tables are of particular disadvantage for mobile devices. Moreover, the large coverage mask lookup table content combined with the mechanism used to fetch the coverage mask during rasterization is a source of inaccuracies, which has to be minimized by additional measures.  
           [0043]    A further document dealing with pre-filter antialiasing techniques is U.S. Pat. No. 5,742,277, which discloses a method where the antialiasing of an internal edge is performed right before display to avoid the problems that arise if this antialiasing is carried out in the blender. This method makes use of the coverage value to form the color of the pixel, but the actual formation of this coverage value is not described. International patent application WO 99/45502 A1 describes a method for creating a coverage alpha value by subsampling the pixels. U.S. Pat. No. 5,369,739 describes a subsampling that can be used for determining the coverage value.  
         SUMMARY OF THE INVENTION  
         [0044]    It is an object of the invention to provide an antialiasing technique with pre-filter, which avoids the above mentioned problems of the prior art solutions.  
           [0045]    It is in particular an object of the invention to reduce the required storage space for coverage masks, while maintaining the advantages of the above presented antialiasing with pre-filtering based on normalized edge functions.  
           [0046]    A method is proposed for determining for a pixel a coverage mask reflecting an orientation of an original edge vector, which pixel is to be employed for displaying at least a part of a geometric primitive on a display, wherein the original edge vector represents an oriented edge of the geometric primitive. The proposed method comprises the following steps:  
           [0047]    a) determining one of four quadrants of a Cartesian coordinate system to which the original edge vector belongs due to its orientation;  
           [0048]    b) transposing the original edge vector into a predetermined one of the four quadrants;  
           [0049]    c) fetching a stored coverage mask which is associated at least indirectly to the transposed edge vector; and  
           [0050]    d) transforming the fetched coverage mask to the quadrant to which the original edge vector belongs.  
           [0051]    Further, a device determining such a coverage mask is proposed. The proposed device comprises a computing portion for determining one of four quadrants of a Cartesian coordinate system to which an original edge vector belongs due to its orientation. The proposed device moreover comprises a quadrant disambiguation portion for transposing an original edge vector into a predetermined one of the four quadrants. The proposed device moreover comprises a coverage mask look-up portion for fetching a stored coverage mask, which coverage mask is associated at least indirectly to a transposed edge vector provided by the transposing portion. Finally, the proposed device comprises a transformation portion for transforming a coverage mask provided by the coverage mask look-up portion to a quadrant determined by the computing portion.  
           [0052]    Further, a graphic presentation system is proposed, which comprises on the one hand a display device and on the other hand a processing device. The processing device includes the same processing portions as the proposed device, and in addition a combining portion for combining transformed coverage masks provided by the transformation portion for a specific pixel and for modifying the color of the pixel for display by the display device based on combined coverage mask.  
           [0053]    Finally, a software program product with a program code for determining such a coverage mask is proposed. The program code is suited for carrying out the steps of the proposed method. It is stored on a machine readable carrier and intended for execution by a signal processing component.  
           [0054]    The invention proceeds from the consideration that the coverage masks required for the edge vectors of each of the four quadrants correspond to each other in a “rotationally symmetric” manner. That is, if an edge vector, which belongs by its orientation to one quadrant and which requires a specific coverage mask, is rotated in steps of 90°, the resulting edge vectors in the other quadrants will require the same specific coverage mask rotated in corresponding steps of 90°. It is therefore proposed to store only coverage masks for edge vectors belonging by their orientation to a selected one of the quadrants, e.g. to the first quadrant. The coverage masks for edge vectors belonging by their orientation to another quadrant are obtained by a simple transformation of a coverage mask fetched for a corresponding edge vector belonging to the selected quadrant. Transposing the original edge vector into the selected quadrant and transforming the fetched coverage mask to the quadrant of the original edge vector can be achieved for example by a negation and/or rotation operation.  
           [0055]    The invention allows a high-quality antialiasing with pre-filtering.  
           [0056]    It is an advantage of the invention that it reduces the storage space required for storing the coverage masks significantly, since only a quarter of the coverage masks have to be stored compared to prior art solutions. At the same time, the invention does not increase the number of required computations for the coverage mask look up.  
           [0057]    It is moreover an advantage of the invention that it allows an adequate smoothing of edges at all angles, and that it does not discard any fragments whatever their size.  
           [0058]    It is equally an advantage of the invention that it is very versatile. It can be applied for example irrespective of the size of the stored coverage masks, and irrespective of the number of the stored coverage masks.  
           [0059]    In a preferred embodiment of the invention, each stored coverage mask is associated to a combination of an edge vector of a specific orientation in the first quadrant and of a specific distance of a vector to the center of a respective pixel. In this case, the distance between the original edge vector and the center of the pixel is determined in addition. A stored coverage mask is then fetched, which is associated on the one hand at least indirectly to the transposed edge vector and on the other hand to the distance determined for the original edge vector. It is an advantage of the invention that it can be applied irrespective of the metric used to measure the position of the edge relative to the currently processed pixel&#39;s center.  
           [0060]    In a further preferred embodiment of the invention, the invention is employed for determining a coverage mask for each edge of the geometric primitive. The resulting coverage masks for all edges can then be combined to a single coverage mask for a respective pixel. Such a combined coverage mask represents the extend of coverage of the pixel by the geometric primitive. This extend can then be used for modifying the color of the pixel in a known manner. As the storage requirements are reduced, the invention also provides the possibility for edge-level parallelism by replicating the coverage masks look up scheme for every edge of the geometric primitive, and thus for increasing the performance and reducing the power consumption of the antialiasing. In a further preferred embodiment of the invention, representative edge vectors having different, predetermined orientations are defined. The representative edge vectors are distributed by these predetermined orientations in a “rotationally symmetric” manner to the four quadrants of the Cartesian coordinate system. That is, if the set of representative edge vectors defined for one quadrant is rotated in steps of 90°, the resulting edge vectors correspond exactly to the set of another quadrant. In this case, one of the representative edge vectors in the predetermined quadrant is selected, which has a similar orientation as the transposed edge vector. Then a stored coverage mask is fetched, which is associated to the selected representative edge vector and thereby indirectly to the transposed edge vector. Since the final occupation of a coverage mask is determined making use of a “rotational symmetry”, a 100% occupation of two adjacent primitives is achieved, and a pixel color can therefore be determined accurately in all situations.  
           [0061]    In a further preferred embodiment of the invention, the predetermined orientations for the representative edge vectors are selected such that the representative edge vectors are distributed uniformly over an angle-related space, e.g. the de x (α) space, to the four quadrants. Thereby, the accuracy of a coverage value indicating the extend of the coverage of a pixel by a geometric primitive, which is determined based on the invention, is higher than the accuracy of a coverage value obtained in the prior art. Also, such an adjusted distribution does not result in any deflection from the 100% occupation of two adjacent primitives due to the “rotational symmetry”.  
           [0062]    The orientation of the edges of a geometric primitive can be clockwise or counter-clockwise. Advantageously, dedicated coverage masks are stored only for one of these possible orientations. A fetched coverage mask is then corrected afterwards, in case the underlying geometric primitive has an orientation for which no dedicated coverage masks are stored. The invention can thus be realized in a triangle traversal order independent manner.  
           [0063]    The proposed method can be implemented in hardware, for instance as part of a 2D/3D graphics hardware accelerator, or in software, for instance as part of a software graphics pipeline. It has to be noted, however, that an implementation in software implies a great performance loss, as the coverage masks transformations are very costly in software.  
           [0064]    If implemented by hardware, the proposed method can be pipelined or parallelized, or a combination of these.  
           [0065]    The invention is further data representation independent, allowing hardware embodiments to use internally any data representation that is considered to be suitable for boosting up the throughput or for the reducing power consumption. Possible data representations are e.g. two&#39;s complement, signed magnitude, etc.  
           [0066]    Since a lookup table used for storing the coverage masks required according to the invention will be small, it can be replicated per edge to reduce the activity factor inside the processing components realizing the antialiasing to lower the power consumption.  
           [0067]    The invention can be used for the purpose of antialiasing of any object whose edges can be described with edge functions, i.e. not only for triangles.  
           [0068]    Other objects and features of the present invention will become apparent from the following detailed description considered in conjunction with the accompanying drawings. It is to be understood, however, that the drawings are designed solely for purposes of illustration and not as a definition of the limits of the invention, for which reference should be made to the appended claims. It should be further understood that the drawings are not drawn to scale and that they are merely intended to conceptually illustrate the structures and procedures described herein. 
       
    
    
     BRIEF DESCRIPTION OF THE FIGURES  
       [0069]    [0069]FIG. 1 a  illustrates a representation of a triangle edge as a vector as known from the prior art;  
         [0070]    [0070]FIG. 1 b  illustrates the association of an arbitrary position to the interior or exterior of a triangle as known from the prior art;  
         [0071]    [0071]FIG. 2 a  illustrates a 16-bit coverage mask encoding scheme as known from the prior art;  
         [0072]    [0072]FIG. 2 b  illustrates the fetching of a coverage mask from a lookup table as known from the prior art;  
         [0073]    [0073]FIG. 2 c  illustrates the determination of a coverage value for a pixel as known from the prior art;  
         [0074]    [0074]FIG. 3 a  illustrates  32  edge vector classes represented through one sample edge vector per class as employed in the prior art;  
         [0075]    [0075]FIG. 3 b  shows edge vectors belonging to one of the edge vector classes represented in FIG. 3 a;    
         [0076]    [0076]FIG. 4 is a diagram schematically illustrating an edge vector class clusterization in an embodiment of the method according to the invention;  
         [0077]    [0077]FIG. 5 is a flow chart schematically illustrating the embodiment of the method according to the invention;  
         [0078]    [0078]FIG. 6 a  depicts schematically an original edge vector belonging to a second quadrant;  
         [0079]    [0079]FIG. 6 b  depicts schematically an edge vector belonging to a first quadrant which is equivalent to the original edge vector of FIG. 6 a;    
         [0080]    [0080]FIG. 6 c  depicts schematically a coverage mask associated to the edge vector of FIG. 6 b;    
         [0081]    [0081]FIG. 6 d  depicts schematically the coverage mask for the original edge vector of FIG. 6 a  obtained by transforming the coverage mask of FIG. 6 c;    
         [0082]    [0082]FIG. 7 a  depicts schematically an original edge vector belonging to a third quadrant;  
         [0083]    [0083]FIG. 7 b  depicts schematically an edge vector belonging to the first quadrant which is equivalent to the original edge vector of FIG. 7 a;    
         [0084]    [0084]FIG. 7 c  depicts schematically a coverage mask associated to the edge vector of FIG. 7 b;    
         [0085]    [0085]FIG. 7 d  depicts schematically the coverage mask for the original edge vector of FIG. 7 a  obtained by transforming the coverage mask of FIG. 7 c;    
         [0086]    [0086]FIG. 8 illustrates schematically an edge vector class disambiguation performed in the embodiment of the method according to the invention;  
         [0087]    [0087]FIG. 9 is a table presenting edge vector class disambiguation rules employed in the embodiment of the method according to the invention;  
         [0088]    [0088]FIG. 10 a  depicts schematically an edge vector belonging to the first quadrant;  
         [0089]    [0089]FIG. 10 b  depicts schematically an edge vector belonging to the first quadrant which is equivalent to the edge vector of FIG. 10 a  and which is obtained by wrap around;  
         [0090]    [0090]FIG. 10 c  depicts schematically a coverage mask associated to the edge vector of FIG. 10 b;    
         [0091]    [0091]FIG. 10 d  depicts schematically the coverage mask of FIG. 10 c  after a rotation by 90°;  
         [0092]    [0092]FIG. 10 e  depicts schematically the coverage mask for the edge vector of FIG. 10 a , the coverage mask being obtained by a vertical flipping transformation applied to the coverage mask of FIG. 10 d;    
         [0093]    [0093]FIG. 11 a  illustrates schematically a first possibility of distributing edge vector classes;  
         [0094]    [0094]FIG. 11 b  illustrates schematically an improved possibility of distributing edge vector classes;  
         [0095]    [0095]FIG. 12 is a listing of coverage mask ROM values;  
         [0096]    [0096]FIG. 13 is a block diagram of a device in which the embodiment of the method according to the invention is implemented; and  
         [0097]    [0097]FIG. 14 is a block diagram of graphic presentation system in which the embodiment of the method according to the invention is implemented. 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0098]    FIGS.  1  to  3  have been described above. An embodiment of the method according to the invention will now be described with reference to FIGS.  4  to  12 . The embodiment enables an antialiasing with pre-filering. More specifically, it allows to determine a coverage mask for an edge vector detected for a triangle by means of a look-up table. The edge vector is detected as in the above described prior art solutions employing a triangle rasterization with edge functions.  
         [0099]    The presented embodiment makes use of the mathematical framework of the above cited documents “A Parallel Algorithm for Polygon Rasterization” and “A New Simple and Efficient Antialiasing with Subpixel Masks”, which are both incorporated by reference herein.  
         [0100]    For the presented embodiment, a new edge vector class clusterization in the four quadrants of the plane is defined. This new clusterization is illustrated in FIG. 4.  
         [0101]    [0101]FIG. 4 shows a first quadrant Q 1 , a second quadrant Q 2 , a third quadrant Q 3  and a fourth quadrant Q 4  in a plane. Each quadrant represents the same 4×4 grid of subpixels for another orientation of edge vectors. The subpixels are indicated as dotted square.  
         [0102]    A triangle&#39;s oriented edge can be represented as a vector extending from a respective source vertex to a respective sink vertex of the triangle, as illustrated in FIGS. 1 a  and  1   b . Given a 4×4 grid of subpixels for a pixel area, a representative edge vector may belong to one of 32 different classes, where each class is identified by its slope and its orientation. The 32 edge vector classes are further clusterized based on their orientation, and thus according to the quadrant to which they belong.  
         [0103]    For the horizontal/vertical edge vector classes, a convention is made. In the embodiment of FIG. 4, horizontal edge vector classes are always associated either to quadrant Q 1  or to quadrant Q 3 , while vertical edge vector classes are always associated either to quadrant Q 2  or to quadrant Q 4 .  
         [0104]    For quadrant Q 1 , eight edge vector classes represented by a respective sample edge vector A-H are depicted in FIG. 4. Each of the sample edge vectors has its source at the center of the last subpixel of the first column of the 4×4 grid of this quadrant. The center of each of the subpixels of this grid is crossed by one of the eight sample edge vectors, except for the first three subpixels of the first column of the grid. Also for quadrant Q 2 , eight edge vector classes represented by a respective sample edge vector are depicted. Each of the sample edge vectors has its source at the center of the last subpixel of the last column of the 4×4 grid of this quadrant. The center of each of the subpixels of this grid is crossed by one of the eight sample edge vectors, except for the first three subpixels of the last row of the grid. Also for quadrant Q 3 , eight edge vector classes represented by a respective sample edge vector are depicted. Each of the sample edge vectors has its source at the center of the last subpixel of the first row of the 4×4 grid of this quadrant. The center of each of the subpixels of this grid is crossed by one of the eight sample edge vectors, except for the last three subpixels of the last column of the grid. Finally, also for quadrant Q 4 , eight edge vector classes represented by a respective sample edge vector are depicted. Each of the sample edge vectors has its source at the center of the first subpixel of the first row of the 4×4 grid of this quadrant. The center of each of the subpixels of this grid is crossed by one of the eight sample edge vectors, except for the last three subpixels of the first row of the grid.  
         [0105]    As can be seen in FIG. 4, a “rotational symmetry” among the quadrants Q 1 -Q 4  exists.  
         [0106]    Only coverage masks for the edge vector classes in the first quadrant Q 1  are stored in a coverage mask lookup table. Due to the “rotational symmetry” among the quadrants, the coverage masks for the edge vector classes in the other quadrants Q 2 -Q 4  can be determined from the coverage masks for the first quadrant Q 1 .  
         [0107]    In the following, it will be explained with reference to the flow chart of FIG. 5, how the coverage mask for a specific pixel can be determined for an arbitrary quadrant edge vector based on the stored coverage masks.  
         [0108]    In a first step  501 , parameters are computed that characterize the edge vector in connection with the pixel center M. More specifically, the parameters d L1 (M), de x (α), and de y (α) are determined based on the above indicated equation (2). From the sign of the parameters de x (α), and de y (α), the original quadrant of the edge vector is derived.  
         [0109]    In a second step  502 , a quadrant disambiguation is performed. More specifically, the edge vector is geometrically transposed to the first quadrant Q 1  by transforming the parameters that characterize this edge vector in connection with the pixel center M, i.e. d L1 (M), de x (α) and de y (α).  
         [0110]    In a third step  503 , an edge vector class disambiguation is performed. More specifically, the parameters of the edge vector resulting in the second step  502  are mapped to parameters of the closest matching representative edge vector for which a coverage mask is stored in the lookup table.  
         [0111]    In a fourth step  504 , the coverage mask for the representative Q 1  edge vector is fetched from the look-up table using the parameters computed in the third step  503  for the representative Q 1  edge vector. The look up table contains exclusively the instances of the Q 1  edge vector classes.  
         [0112]    In a fifth step  505 , a geometrical transformation of the fetched coverage mask to the original quadrant is carried out. The geometrical transformation may comprise mask rotations and bitwise negations and employs the information about the original quadrant of the original edge vector.  
         [0113]    In a sixth step  506 , the final coverage mask is obtained by correcting the coverage mask resulting in the fifth step  505  according to the orientation convention of the triangle, i.e. clockwise or counter-clockwise.  
         [0114]    Steps  501 - 506  are repeated for each edge of a triangle covering the pixel. Then, a coverage value is determined by combining all final coverage masks generated for the pixel, and the resulting coverage value is used for modifying the color of the pixel for display as described above with reference to FIG. 2 c.    
         [0115]    The six steps  501 - 506  will be explained in more detail in the following.  
         [0116]    Steps  501  and  504  in the flow chart of FIG. 5 are identical with corresponding steps that are performed in the method of above cited documents “A Parallel Algorithm for Polygon Rasterization” and “A New Simple and Efficient Antialiasing with Subpixel Masks”. In these prior art documents, the look up process corresponding to step  504  is performed on a much larger lookup table with increased access latency, though.  
         [0117]    Steps  502  and  505  in the flow chart of FIG. 5 will be explained in synergy, but in a practical implementation, they can be decoupled.  
         [0118]    Steps  502  and  505  are intended to transform an arbitrary quadrant edge vector into a Q 1  edge vector, in order to require for the coverage mask retrieval in step  504  only a reduced coverage masks lookup table for representative Q 1  edge vectors. After the coverage mask has been fetched from the lookup table, inverse transformations have to be operated on the coverage mask, in order to obtain the correct coverage mask for the original, arbitrary quadrant edge vector.  
         [0119]    The forward mapping to quadrant Q 1  in step  502  and the backward mapping from quadrant Q 1  in step  505  are based on two important properties of the normalized edge function. The first property consists in that the normalized edge function is invariant with the origin of its defining vector along its associated line. The second property consists in that the normalized edge function is invariant with the length of its defining vector along its associated line.  
         [0120]    In case the original edge vector belongs to the first quadrant Q 1 , no transformations is required in steps  502  and  505 .  
         [0121]    The transformations required for the case that the original edge vector belongs to the second quadrant Q 2  are presented in FIGS. 6 a - 6   d.    
         [0122]    [0122]FIGS. 6 a  and  6   b  illustrate the transformation in step  502 . Both figures show the area  30 ,  31  of a pixel and its center M. FIG. 6 a  further shows a Q 2  edge vector V 4  starting at point A. The Q 2  edge vector of FIG. 6 a  is transformed into an equivalent Q 1  edge vector by a clock wise rotation by 90°. The resulting Q 1  edge vector V 5  starting at point A is shown in FIG. 6 b.    
         [0123]    The transformation of step  502  can be expressed by the following equations:  
         Δ y   Q1   =−Δx   Q2             de   x   Q1   =−de   y   Q2    
         
       Δx 
       Q1 
       =Δy 
       Q2 
                 de 
       y 
       Q1 
       =de 
       x 
       Q2  
     
         d L1   Q1 =d L1   Q2    
         [0124]    The indices Q 1  and Q 2  indicate the quadrant of the edge vector to which the respective parameter belongs.  
         [0125]    [0125]FIGS. 6 c  and  6   d  illustrate the transformation in step  505 . The Q 1  edge vector of FIG. 6 b  is used in steps  503  and  504  to fetch an associated coverage mask from the coverage mask lookup table. The fetched coverage mask is presented in FIG. 6 c  in form of a 4×4 grid  32  of subpixels, in which some subpixels are black, i.e. lit. This mask is rotated counter-clockwise by 90° to obtain the coverage mask for the original Q 2  edge vector. The resulting coverage mask is presented in FIG. 6 d  in form of a 4×4 grid  33  of subpixels, in which other subpixels are lit.  
         [0126]    The transformation of step  505  can be expressed by the following equation:  
         Coverage_Mask Q2 =rotate_counterclockwise — 90(Coverage_Mask Q1 )  
         [0127]    where Coverage_Mask Q2  represents the 16 bits of the coverage mask for the original Q 2  edge vector, where Coverage_Mask Q1  represents the 16 bits of the coverage mask for the equivalent Q 1  edge vector and where the operator rotate_counterclockwise — 90( ) denotes a counter-clockwise rotation by 90° of a 4×4 grid of subpixels that is encoded as a 16-bit coverage mask.  
         [0128]    The transformations required for the case that the original edge vector belongs to the third quadrant Q 3  are presented in FIGS. 7 a - 7   d.    
         [0129]    [0129]FIGS. 7 a  and  7   b  illustrate the transformation in step  502 . Both figures show the area  40 ,  41  of a pixel and its center M. FIG. 7 a  further shows a Q 3  edge vector V 6  starting at point A. The Q 3  edge vector of FIG. 7 a  is transformed into an equivalent Q 1  edge vector V 7  by flipping its orientation. The resulting Q 1  edge vector V 7  is ending at point A is shown in FIG. 7 b.    
         [0130]    The transformation of step  502  can be expressed by the following equations:  
         
       Δx 
       Q1 
       =−Δx 
       Q3 
                 de 
       y 
       Q1 
       =−de 
       y 
       Q3  
     
         
       Δy 
       Q1 
       =−Δy 
       Q3 
                 de 
       x 
       Q1 
       =−de 
       x 
       Q3  
     
         
       d 
       L1 
       Q1 
       =−d 
       L1 
       Q3  
     
         [0131]    The indices Q 1  and Q 3  indicate the quadrant of the edge vector to which the respective parameter belongs.  
         [0132]    [0132]FIGS. 7 c  and  7   d  illustrate the transformation in step  505 . The Q 1  edge vector of FIG. 7 b  is used in steps  503  and  504  to fetch an associated coverage mask from the coverage mask lookup table. The fetched coverage mask is presented in FIG. 7 c  in form of a 4×4 grid  42  of subpixels, in which some subpixels are black, i.e. lit. This mask is negated bitwise to obtain the coverage mask for the original Q 3  edge vector V 6 . The resulting coverage mask is presented in FIG. 7 d  in form of a 4×4 grid  43  of subpixels, in which other subpixels are lit.  
         [0133]    The transformation of step  505  can be expressed by the following equation:  
         Coverage_Mask Q3 =not(Coverage_Mask Q1 )  
         [0134]    where Coverage_Mask Q3  represents the 16 bits of the coverage mask for the original Q 3  edge vector, where Coverage_Mask Q1  represents the 16 bits of the coverage mask for the equivalent Q 1  edge vector, and where the operator not( ) denotes a bitwise negation of the 16-bit coverage mask.  
         [0135]    In case the original edge vector belongs to the fourth quadrant Q 4 , the required operations are fused computations Q 4 →Q 2 →Q 1 →Q 2 →Q 4 . That is, the original Q 4  edge vector is first transformed into an equivalent Q 2  edge vector and the resulting Q 2  edge vector is then transformed into an equivalent Q 1  edge vector. The coverage mask for the equivalent Q 1  edge vector is first transformed into a coverage mask for the equivalent Q 2  edge vector, and the coverage mask for the Q 2  edge vector is then transformed into a coverage mask for the original Q 4  edge vector. The transformations for the forward transition Q 4 →Q 2  and for the backward transition Q 2 →Q 4  are similar to the above described transformations Q 3 →Q 1  and Q 1 →Q 3 , respectively.  
         [0136]    The fused computations for the forward transformation in step  502  can be expressed by the following equations:  
         
       Δy 
       Q1 
       =−Δx 
       Q2 
       =Δx 
       Q4 
                 de 
       x 
       Q1 
       =de 
       y 
       Q4  
     
         
       Δx 
       Q1 
       =Δy 
       Q2 
       =−Δy 
       Q4 
                 de 
       y 
       Q1 
       =−de 
       x 
       Q4  
     
         
       d 
       L1 
       Q1 
       =d 
       L1 
       Q2 
       =−d 
       L1 
       Q4  
     
         [0137]    The indices Q 1 , Q 2  and Q 4  indicate the quadrant of the edge vector to which the respective parameter belongs.  
         [0138]    The fused computations for the backward transformation in step  505  can be expressed by the following equation:  
               Coverage_Mask   Q4     =            not                   (     Coverage_Mask   Q2     )                   =            not                   (     rotate_counterclockwise      _      90                   (     Coverage_Mask   Q1     )       )                                   
 
         [0139]    where Coverage_Mask Q4  represents the  16  bits of the coverage mask for the original Q 4  edge vector, where Coverage_Mask Q2  represents the 16 bits of the coverage mask for the equivalent Q 2  edge vector, where Coverage_Mask Q1  represents the 16 bits of the coverage mask for the equivalent Q 1  edge vector, where the operator not( ) denotes a bitwise negation of the 16-bit coverage mask, and where the operator rotate_counterclockwise — 90( ) denotes a counter-clockwise rotation by with 90° of a 4×4 grid of subpixels that is encoded as a 16-bit coverage mask.  
         [0140]    Due to the fact that the coverage masks lookup table contains only entries for the Q 1  edge vector classes, the indexing scheme for the lookup table becomes simpler compared to the prior art solutions. The index can be composed taking into account only the transformed parameters d L1   Q1 (M) and de x   Q1 (α). The Q 1  edge vector classes can be distinguished from each other by the de x   Q1 (α) value only. The range for the parameter de x   Q1 (α) is de x   Q1 (α)ε[0,+1). The vertical edge vector class found at the intersection between the first quadrant Q 1  and the second quadrant Q 2  belongs according to the convention mentioned with reference to FIG. 4 to the second quadrant Q 2 . The coverage masks lookup table, which contains only coverage masks for the Q 1  edge vector classes, will also be referred to as coverage masks ROM (read only memory).  
         [0141]    Step  503  in the flow chart of FIG. 5, which is responsible for the edge vector class disambiguation, will now be explained with reference to FIGS.  8  to  10 .  
         [0142]    As briefly mentioned above, it is the task of the edge vector class disambiguation step  503  to map the parameters of the Q 1  edge vector resulting in step  502  into parameters of the closest matching representative edge vector whose coverage mask is resident in the lookup table.  
         [0143]    The Q 1  edge vector resulting in step  502  can have any slope, while coverage masks are only stored for edge vector classes having one of eight discrete slopes. The Q 1  edge vector thus has to be classified in one of the eight Q 1  edge vector classes for which coverage masks are stored in the coverage masks ROM. Conceptually, the disambiguation process of the edge vector class is reduced to the problem of finding the boundaries between neighboring quadrant one edge vector classes for which masks are stored in the coverage masks ROM.  
         [0144]    [0144]FIG. 8 is a diagram presenting the edge vector classes of the first quadrant Q 1  represented by edge vectors A-H, and in addition eight bisectors Bisector_AB, Bisector_BC, . . . , Bisector_GH, Bisector_H_Vertical. Each bisector is represented by a line starting at the source of the edge vectors A-H and extending between two adjacent ones of the edge vectors A-H. The index of the bisectors denotes the two representative edge vectors A-H between which the associated line extends. Only the line of the last bisector Bisector_H_Vertical extends between the last edge vector H and a vertical line. To each bisector, a value of the parameter de x   Q1 (α) is associated in accordance with the slope of its line. These values can equally be determined in accordance with above indicated equations (2).  
         [0145]    An incoming Q 1  edge vector can now be classified to one of the Q 1  edge vector classes based on its own de x   Q1 (α) value, the bisector lines representing the limits for the association to a specific Q 1  edge vector class. For example, if the de x   Q1 (α) value of an incoming Q 1  edge vector lies between the de x   Q1 (α) values of bisectors Bisector_AB and Bisector_BC, then the incoming Q 1  edge vector is classified to edge vector class B and the de x   Q1 (α) value of the incoming Q 1  edge vector is substituted by the de x   Q1 (α) value of the edge vector class B.  
         [0146]    Since only eight edge vector classes A-H are represented in the coverage masks ROM, only three bits are needed to encode their de x   Q1 (α) value in the coverage masks ROM index. This 3-bit code is produced directly as a result of the edge vector class disambiguation with bisectors. In the coverage masks ROM,  256  coverage masks are stored. As in prior art, thus five bits remain available in the ROM index to encode 32 L 1 -norm distances d L1 (M). That is, coverage masks for 32 different values of the distance d L1 (M) from the pixel center M to a particular edge slope can be stored for each edge vector class.  
         [0147]    The rules for the edge vector class disambiguation with bisectors are presented in FIG. 9.  
         [0148]    [0148]FIG. 9 is a table which presents in a first column ranges for the de x   Q1 (α) values of incoming Q 1  edge vectors. The first range extends from 0 to the de x   Q1 (α) value of the first bisector Bisector_AB. The following seven ranges extend respectively from the de x   Q1 (α) value of one bisector to the de x   Q1 (α) value of the next bisector. A last range extends from the last bisector Bisector_H_vertical to +1.  
         [0149]    A second column of the table of FIG. 9 presents the disambiguated de x   Q1 (α) values associated to a respective range in the first column, i.e. the de x   Q1 (α) value of a respective representative edge vector class de x   A  to de x   H . These disambiguated de x   Q1 (α) values represent constants, which may be programmed in hardware. Thus, no computational effort is required at the rasterization time to compute them.  
         [0150]    A third column of the table of FIG. 9 with the heading “de x   ROM     —     index     —     code ” presents the 3-bit code required to encode the disambiguated de x   Q1 (α) value in the coverage masks ROM index. The code represents from top to bottom values from “000” to “111”, and the value in the last row is “000” again.  
         [0151]    A fourth column of the table of FIG. 9 with the heading “wrap_around_flag” is required for handling an exceptional case in a specific way, as will be explained in the following.  
         [0152]    Referring to FIG. 8, an exceptional case appears for the disambiguation of any incoming Q 1  edge vector whose slope lies between Bisector_H_Vertical and the vertical. Normally, such an edge vector would have to be disambiguated to a vertical edge vector class, but according to the convention presented in FIG. 4, this edge vector class belongs to the second quadrant Q 2 , not to the first quadrant Q 1 .  
         [0153]    Therefore, such exceptional edge vectors are disambiguated by wrapping around to the edge vector class A as presented in the last row in the table of FIG. 9. Further, a binary condition signal wrap_around_flag is set according to the fourth column of the table of FIG. 9. This flag is not set in any other case.  
         [0154]    The determined ROM index can then be used in step  504  to fetch the associated coverage mask from the lookup table.  
         [0155]    When the coverage mask has been fetched from the lookup table in step  504 , a correction to the fetched coverage mask has to be performed before proceeding with step  505 , in case the condition signal wrap_around_flag was set in step  503 .  
         [0156]    This coverage mask correction process is presented in FIGS. 10 a - 10   e.    
         [0157]    [0157]FIGS. 10 a  and  10   b  both show the area  50 ,  51  of a pixel and its center M. FIG. 10 a  further presents an original Q 1  edge vector V 8  having a slope in the range between the last bisector line Bisector_H_Vertical and the vertical. FIG. 10 b  shows an equivalent Q 1  edge vector V 9  belonging to edge vector class A, which is obtained by wrap around.  
         [0158]    The equivalent Q 1  edge vector V 9  is used to fetch an associated coverage mask from the lookup table. This coverage mask is presented in FIG. 10 c  in form of a 4×4 grid  52  of subpixels, in which some subpixels are black, i.e. lit. The fetched coverage mask is rotated counter-clockwise by 90°. The resulting coverage mask is presented in FIG. 10 d  in form of a 4×4 grid  53  of subpixels, in which some other subpixels are lit. The corrected coverage mask for the original Q 1  edge vector V 8  is then obtained by a final vertical flipping transformation. The corrected coverage mask is presented in FIG. 10 e  in form of a 4×4 grid  54  of subpixels, in which still other subpixels are lit.  
         [0159]    The correction process can be expressed by the following equation:  
         Adjusted_Mask Q1 =flip_vertically(rotate_counterclockwise — 90(Coverage_Mask Q1 ))  
         [0160]    where Adjusted_Mask Q1  represents the 16 bits of the desired corrected coverage mask, where Coverage_Mask Q1  represents the 16 bits of the fetched coverage mask, where the operator rotate_counterclockwise — 90( ) denotes a counter-clockwise rotation by 90° of a 4×4 grid of subpixels that is encoded as a 16-bit coverage mask, and where the operator flip_vertically( ) denotes a vertical mirroring of a 4×4 grid of subpixels that is encoded as a 16-bit coverage mask. The mirroring of the mask was chosen in order to ensure that the coverage mask is resembling geometrically the pixel area covered by the edge of the triangle.  
         [0161]    Step  506  in the flow chart of FIG. 5, finally, is implemented to ensure that the described coverage mask lookup scheme can be employed to work with triangles with edges oriented clockwise or counter-clockwise, as required for OpenGL or Microsoft&#39;s DirectX-Direct3D® compliance.  
         [0162]    The coverage masks in the coverage masks ROM are computed only for a clockwise orientation of the triangle&#39;s edge vectors. For triangles with edges oriented counter-clockwise, the coverage mask obtained through the operations described so far has to be bitwise negated with the operator not( ) to deliver the final coverage mask. The orientation of the triangle&#39;s edges can be detected by computing the sign of the edge function E AB (x C ,y C ) presented above as equation (1), or equivalently, by computing the normalized edge function d L1   AB (C), the indices A and B representing in both cases a source vertex A and a sink vertex B of an edge vector for the triangle. Alternatively, any other cyclic permutation of triangle&#39;s vertices A, B, C could be used. If the computed edge function values are positive, the edges of the triangle are oriented clockwise, if they are negative the edges are oriented counter-clockwise. In case they are equal to zero, the triangle is degenerate and it is not rasterized at all. Such computations are required anyhow for the triangle interpolation setup, i.e., δ z /δ x , δ z /δ y  etc.  
         [0163]    For summarizing the described steps  501  to  506 , a complete hardware algorithm for fetching the coverage mask for an edge vector that presents a partial coverage over the current rasterization position, i.e. over the current pixel, is presented:  
         [0164]    1. Compute de x  and de y  for the edge vector and from the signs of de x  and de y  determine the initial quadrant for the edge vector. This is performed only once per edge.  
         [0165]    2. Compute d L1  for the current rasterization position that the edge touches.  
         [0166]    3. For quadrant disambiguation, perform the next operations if the initial quadrant for the edge vector is the following:  
         [0167]    Q 1 : de x   Q1 =de x  and d L1   ROM     —     index =d L1    
         [0168]    Q 2 : de x   Q1 =−de y  and d L1   ROM     —     index =d L1    
         [0169]    Q 3 : de x   Q1 =−de x  and d L1   ROM     —     index =−d L1    
         [0170]    Q 4 : de x   Q1 =de y  and d L1   ROM     —     index =−d L1    
         [0171]    4. For the edge vector class disambiguation, disambiguate the value for de x   Q1  according to the table of FIG. 9, thus producing a 3-bit de x   ROM     —     index     —     code  value. If this disambiguation has produced a wrap-around set wrap_around_flag, else unset wrap_around_flag.  
         [0172]    5. Use the 3-bit de x   ROM     —     index     —     code  value and the 5 most significant bits of d L1   ROM     —index    to compose an address, and fetch the coverage mask MASK from the coverage masks ROM based on the composed address.  
         [0173]    6. If necessary, adjust the coverage mask MASK by producing an intermediary coverage mask MASK_ADJUSTED, i.e.:  
         [0174]    If the wrap_around_flag was set then perform  
         [0175]    MASK_ADJUSTED=flip_vertically(rotate_counterclockwise — 90(MASK))  
         [0176]    Else perform  
         [0177]    MASK_ADJUSTED=MASK  
         [0178]    7. If the initial quadrant for the edge vector was the following then compute another intermediary coverage mask COVERAGE_MASK:  
         [0179]    Q 1 :  
         [0180]    COVERAGE_MASK=MASK_ADJUSTED  
         [0181]    Q 2 :  
         [0182]    COVERAGE_MASK=rotate_counterclockwise — 90(MASK_ADJUSTED)  
         [0183]    Q 3 :  
         [0184]    COVERAGE_MASK=not(MASK_ADJUSTED)  
         [0185]    Q 4 :  
         [0186]    COVERAGE_MASK=not(rotate_counterclockwise — 90(MASK_ADJUSTED))  
         [0187]    8. Compute the final coverage mask for the edge vector by testing the orientation of the triangle&#39;s edges.  
         [0188]    If triangle&#39;s edges are oriented clockwise (d L1   AB (C)&gt;0 or E AB (x C ,y C )&gt;0) perform:  
         [0189]    FINAL_COVERAGE_MASK=COVERAGE_MASK  
         [0190]    Else perform:  
         [0191]    FINAL_COVERAGE_MASK=not(COVERAGE_MASK)  
         [0192]    The accuracy achieved with the presented embodiment can be further increased by adjusting the distribution of the eight edge vector classes in the Q 1  space.  
         [0193]    The initial distribution of the eight edge vector classes in the Q 1  space has a tremendous impact on the coverage masks ROM content and affects also the precision of the antialiasing process performed on the fly during rasterization. If the eight edge vector classes from the first quadrant Q 1  are selected to pass through the subpixel centers of the pixel, the edge vector classes are not uniformly spread in the angular space of the first quadrant Q 1  and also the error distribution will not be uniform in the quadrant. This distribution was used for the representation of the edge vector classes in FIGS. 4 and 8, in correspondence with the prior art described with reference to FIGS. 3 a  and  3   b . This distribution is shown again for reasons of comparison in FIG. 11 a . FIG. 11 a  presents a 4×4 grid  60  of subpixels depicted as dotted squares. Further, eight edge vectors A-H representing a respective edge vector class are shown. Each of the edge vectors passes through the center of at least one of the subpixels. It can be seen that this distribution is non-uniform with regard to the achieved vector slopes.  
         [0194]    A series of experiments showed that a larger increase in accuracy is obtained by spreading the eight edge vector classes uniformly in the de x   Q1  (α) space. Such a uniform distribution is presented in FIG. 11 b . FIG. 11 b  shows again a 4×4 grid  61  of subpixels depicted as dotted squares. Further, eight edge vectors A-H representing a respective edge vector class are shown. Here, however, the edge vectors do not necessarily pass through the center of one of the subpixels. Rather, the difference in the slope from one vector to the next is approximately the same, and thus the distribution is almost uniform.  
         [0195]    Such a uniform distribution provides a two-fold benefit. On the one hand, the errors of the antialiasing scheme during the edge vector class disambiguation are distributed more evenly among the representative edge vectors. On the other hand, the area absolute error upper bound is reduced from 15.25% manifested by the prior art to 8.34% for the present scheme.  
         [0196]    For a setup with eight edge vector classes uniformly spread in the de x   Q1 (α) space of the first quadrant Q 1 , the de x   Q1 (α) values of the bisectors presented in the first column of the table of FIG. 9 are:  
         [0197]    de x   Bisector     —     AB =0.0663522979;  
         [0198]    de x   Bisector     —     BC =0.1909830036;  
         [0199]    de x   Bisector     —     CD =0.3150379610;  
         [0200]    de x   Bisector     —     DE =0.4384471872;  
         [0201]    de x   Bisector     —     EF =0.5615528130;  
         [0202]    de x   Bisector     —     FG =0.6849620384;  
         [0203]    de x   Bisector     —     GH =0.8090169944;  
         [0204]    de x   Bisector     —     H     —     Vertical =0.9336477008.  
         [0205]    Further, a possible coverage masks ROM content for this setup will be presented. The coverage mask encoding, i.e. the association of 16 bits to a 4×4 grid of subpixel, was illustrated in FIG. 2 a . There are several ways of associating 8-bit index values [0] to [255] to a coverage mask, one of which will be presented. If the index in the coverage masks ROM is represented as an 8-bit string, the first 3 msb represent the code for the edge vector class as presented in the table of FIG. 9. The other 5 bits represent the 5 lsb (least significant bits) of the d L1   ROM     —     index  value, with d L1   ROM     —     index  ε[−0.5,+0.5). The d L1   ROM     —     index  value is coded as a two&#39;s complement signed number which is shifted left by 5 positions. Thus a d L1   ROM     —     index  value of −{fraction (16/32)} is coded in the 5 lsb of the index as “10000”, a d L1   ROM     —     index  value of −{fraction (15/32)} is coded as “10001”, and a d L1   ROM     —     index  value of +{fraction (15/32)} is coded as “01111”.  
         [0206]    A coverage masks ROM associating such 8-bit index values to 16-bit coverage masks is presented in FIGS. 12 a - 12   d . FIGS. 12 a - 12   d  represent a single list distributed over four pages.  
         [0207]    The quality of the achieved antialiasing could be increased without making modifications to the proposed method, by taking into account more quadrant Q 1  edge vector classes or more accurate coverage masks (5×5, 6×6, etc.), or both.  
         [0208]    The presented method can be implemented in various devices and systems.  
         [0209]    [0209]FIG. 13 is a schematic block diagram of a device  100  in which the presented method is implemented by way of example. The device  100  can be for instance a computer or a mobile terminal. The device  100  comprises among other components a display  101 , a chip  102 , a ROM  103  and a processing component  104 . The presented method is implemented actually in the chip  102  as a hardware algorithm. The chip  102  comprises to this end connected in series to each other a computing portion  111  for carrying out step  501 , a quadrant disambiguation portion  112  for carrying out step  502 , an edge vector class disambiguation portion  113  for carrying out step  503 , a coverage mask lookup portion  114  for carrying out step  504 , a transformation portion  115  for carrying out step  505  and a correction portion  116  for carrying out step  506  in the flow chart of FIG. 5. Further, the chip  102  comprises a combining portion  117  for combining for each pixel the coverage masks determined for all edges of a triangle covering the respective pixel, for determining based on the combined coverage masks a respective coverage value and for modifying the color of the pixel accordingly.  
         [0210]    The computing portion  111  receives the graphical data on a respective triangle that is to be displayed on the display  101  by the processing component  104 . The coverage mask lookup portion  114  has access to the ROM  103 , which stores the coverage masks lookup table. The coverage masks lookup table content has to account only for a quarter of the number of the edge vector classes required in the prior art. The modified color for each pixel is provided by the combining portion  117  to the display  101  component for display.  
         [0211]    The forward and backward transformations according to steps  502  and  505  carried out by the quadrant disambiguation portion  112  and the transformation portion  115 , respectively, ensure by construction that two adjacent triangles, both front-facing or both back-facing, always complement each other, and that a total coverage of more than 4×4 subpixels is impossible. There is no need for additional redundancy to be built in the coverage masks lookup table for this purpose as was the case for prior art.  
         [0212]    The sign complementation unary operator employed by the quadrant disambiguation portion  112 , which depends on the underlying data representation, may be realized with little additional cost. A first approach consists in toggling only the sign bit, if the signed magnitude number representation is employed. A second approach consists in negating the operand bitwise and then adding a ‘one’ in the ulp (unit in least significant position) position, if the two&#39;s complement number representation is employed. The computation may also be masked in computations required elsewhere or be computed once and reused many times. This is a typical case for de x (α) and de y (α) sign complementation computed once during a triangle setup stage and then reused for all the fragments that lie on the edge vector boundary.  
         [0213]    The coverage mask rotation operator rotate_counterclockwise — 90( ) employed by the transformation portion  115  can be realized simply by the proper routing of signals representing the bits in the coverage mask.  
         [0214]    The bitwise negation operator not( ) employed by the transformation portion  115  requires an inverter per bit of the coverage mask. This may be unnecessary, if a logic family with differential logic inputs/outputs, e.g. DCVSL (Differential Cascade Voltage Switched Logic), is employed.  
         [0215]    The edge vector class disambiguation portion  113  may comprise a fast logic circuit with logarithmic depth, which implements a sorting tree for edge vector class disambiguation with the outputs presented in columns three and four of the table of FIG. 9. Moreover, the sorting tree can be evaluated once during a triangle setup stage, and then the result can be reused for all the fragments that lie on the edge vector boundary.  
         [0216]    The correction of the fetched coverage mask, in case the condition signal wrap_around_flag was asserted, has to be introduced between step  504  and step  505 , and may be implemented in an additional portion between the coverage mask lookup portion  114  and the transformation portion  115 , or alternatively in one of these two portions  114 ,  115 . The correction may imply for instance the hardware costs of one additional 2:1 MUX (multiplexer) controlled by the signal wrap_around_flag. Alternatively, no cost at all are necessary for the rotation and the mirroring required for the correction of the coverage mask, because these operations can be fused together to be implemented only by the proper routing of the hardware signals representing the bits in the coverage mask.  
         [0217]    The hardware of the correction portion  116  may comprise a 2:1 MUX and an inverter per bit of the coverage mask. The same hardware considerations apply to the bitwise negation in this portion  116  as explained for the transformation portion  115 .  
         [0218]    It is to be noted that the depicted processing portions of the chip do not have to be separate portions. For example, specific processing steps may be carried out by a single part of a circuit for several portions. Further, the depicted portions do not have to be connected directly to each other, as there may be other portions performing additional processing steps which are arranged between them.  
         [0219]    [0219]FIG. 14 is a schematic block diagram of a graphic presentation system  200  in which the method is implemented by way of example. The system  200  comprises a processing device  201  and a display device  202 , which are connected to each other. The processing device  201  can be for instance a computer and the display device  202  can be for instance a monitor connected to the computer. The processing device  201  comprises among other components a signal processing component  211 , a ROM  212  for storing a coverage masks lookup table and a storage component  213  for storing a software code that can be executed by the processing component  211 . The software codes stored in the storage component  213  comprise a software algorithm  214  implementing the presented method. When this software algorithm  214  is loaded into the processing component  211  and executed, available graphic data on a triangle that is to be displayed is processed according to steps  501  to  506  in the flow chart of FIG. 5. In addition, the software algorithm takes care of combining for each pixel the coverage masks determined for all edges of a triangle covering the respective pixel, of determining a respective coverage value based on the combined coverage masks, and of modifying the color of the pixel accordingly. The determined color of the pixels is then provided to the display device  202  for display of the triangle. For fetching a coverage mask from a lookup table in step  504 , the processing component accesses the ROM  212 .  
         [0220]    It is to be understood that the invention could also be implemented in a device by software or in a system by hardware. In case of a hardware implementation, the hardware is further not necessarily integrated in a chip.  
         [0221]    While there have shown and described and pointed out fundamental novel features of the invention as applied to a preferred embodiment thereof, it will be understood that various omissions and substitutions and changes in the form and details of the devices and methods described may be made by those skilled in the art without departing from the spirit of the invention. For example, it is expressly intended that all combinations of those elements and/or method steps which perform substantially the same function in substantially the same way to achieve the same results are within the scope of the invention. Moreover, it should be recognized that structures and/or elements and/or method steps shown and/or described in connection with any disclosed form or embodiment of the invention may be incorporated in any other disclosed or described or suggested form or embodiment as a general matter of design choice. It is the intention, therefore, to be limited only as indicated by the scope of the claims appended hereto.