GB2245806A - Generating an image - Google Patents

Abstract

Apparatus for generating an image of objects in a three dimensional space for display on a two dimensional regular pixel array includes means for anti-alias filtering which causes multiple rendition E, E', E" of the image with each rendition offset by a fraction of the pixel size with respect to the previous rendition. Image primitives P are rendered by a scan line algorithm using a linked active polygon list and a deleted polygon list to enable vertical offsets to be effected. The deleted polygon list stores primitives which would not be effective for a given line but for the offset to enable anti-alias filtering. These polygons would not normally be available for processing when using the scan line algorithm. <IMAGE>

Description

DESCRIPTION GENERATING AN IMAGE The invention relates to a method of generating an image of objects in a three dimensional space in the form of a two dimensional regular pixel array comprising a series of rows of picture elements, the method comprising: a) generating and storing a plurality of primitive descriptors, each comprising a geometrical and surface description of a primitive of the desired image, b) using the sorted primitive descriptors to render a plurality of point-sampled intermediate pixel arrays while imposing for each such rendition a different pre-determined offset between the primitives and the sample points, and c) combining the plurality of intermediate pixel arrays to generate and store a corresponding filtered pixel array.

The invention further relates to apparatus for generating an image of objects in a three dimensional space for display on a two dimensional regular pixel array comprising a series of rows of picture elements (pixels), comprising: means for generating and storing a plurality of primitive descriptors, each comprising a geometrical and surface description of a primitive of the desired image, means for sorting the primitive descriptors and rendering a plurality of point sampled intermediate pixel arrays, means for imposing for each such rendition a different pre-determined offset between the primitives and the sample points, and means for combining the plurality of intermediate pixel arrays to generate and store a corresponding filtered pixel array.

A method of the type set forth in the opening paragraph is known from 'Fast Spheres, Shadows, Textures, Transparencies and Image Enhancements in Pixel Planes' by Henry Fuchs et al in Computer Graphics, Vol. 19, No. 3 (SIGGRAPH 85) at pages 111-120, in particular at pages p. 119 and 120 under 'Successive Refinement'.According to Fuchs, "Each pixel (xy) is sub-divided into a grid of sub-pixels so that each sub-pixel has an address of the form (x+xoffset, y+yoffset). We generate the image several times, for example 16, each time offsetting the image slightly by some (xoffset, yoffset) in such a way that the sample points within a pixels area form a reasonable distribution. (The shift is easily achieved by adding A.xoffset + B.yoffset to the C.coefficient of each broadcast triple.) Two sets of colour buffers are maintained, one to store the colour generated by the latest image generation offset and the other to store a running average as we move around the sub-pixel grid." The primary aim of the filtering applied by this method is to#reduce aliasing artefacts caused by the sampling process.One obtrusive artefact of aliasing is the staircase structure imposed on an edge of a primitive which slopes relative to the pixel array axes. This effect becomes particularly obtrusive in the case where the edge of the primitive is nearly aligned with an axis of the pixel array.

The invention provides a method as set forth in the opening paragraph, characterised in that the intermediate pixel arrays are one-dimensional arrays generated and combined in accordance with steps b) and c) sequentially for each pixel row in turn.

By generating the intermediate pixel arrays one row (or scan line) at a time, it is possible to implement the hardware with smaller, faster memories in the pixel processing stage. This gives the advantage of requiring a smaller memory capacity and of faster pixel processing.

The method may further comprise, for each new pixel row in the series, the preliminary step al) of identifying a subset of the primitives as being active for the new pixel row, the steps b) and c) of the method being performed so as to ignore the descriptors of primitives not in the active subset.

The method may further comprise for each new pixel row the further preliminary step a2) of identifying a further subset of the primitives as being potentially active in the new row depending on the magnitude of the offset, the steps b) and c) being performed so as to treat as active primitives in the further subset selectively in response to each offset.

By identifying further primitives which are potentially active on a given scan line depending on the magnitude of any particular offset the scan line algorithm can be presented with the necessary information in the column direction which is not normally available to it but which is required to enable anti-alias filtering by multiple rendition.

Each step a) may include generating and storing start row data identifying, for each primitive, the first pixel row in the series for which the primitive is active, while the step al),includes maintaining a list of active primitives and updating the said list by using the start row data to identify and add to the list any primitive first active in the new pixel row. The start row data may comprise a list identifying for each pixel row any primitive first active in that row.

The step a) may include generating and storing end row data identifying for each primitive the last pixel row in the series for which the primitive is active and the step al) may comprise deleting a primitive from the active primitive list when the plurality of intermediate pixel arrays for the last row have been rendered. The step a2) may comprise maintaining a deleted primitive list, identifying primitives deleted from the active primitive list which may yet be required to be treated as active in response to one or more of said offsets.

Another method of identifying further primitives which are potentially active on a given scan line is to delete the primitives from the active primitive list one row later than the row on which they actually end. With this method the requirement of maintaining a deleted primitive list is replaced by extending the checks performed on each span to see whether or not it should be rejected.

Each primitive descriptor may include a pointer field for a pointer to a further primitive descriptor and the active primitive list may be formed for each row by using a succession of such pointers to link the active primitives together in a chain. The same pointer field may be used as part of the start row data to link together in the chain two or more primitives which are first active in the same pixel row. The same pointer field may be used to link together in a chain the further subset of primitives.

The invention further provides apparatus for generating an image of objects in a three dimensional space for display on a two dimensional regular pixel array comprising a series of rows of picture elements (pixels), comprising: means for generating and storing a plurality of primitive descriptors, each comprising a geometrical and surface description of a primitive of the desired image, means for sorting the primitive descriptors and rendering a plurality of point sampled intermediate pixel arrays, means for imposing for each such rendition a different pre-determined offset between the primitives and the sample points, and means for combining the plurality of intermediate pixel arrays to generate and store a corresponding filtered pixel array, characterised in that the intermediate pixel arrays are one dimensional arrays.

The apparatus may further compriseng means for identifying a subset of the primitives as being active for the new pixel row.

Means may be provided for identifiying a further subset of the primitives as being potentially active in the new row, depending on the said offset.

The apparatus may further comprise means for generating and storing start row data identifying for each primitive the first pixel row in the series for which the primitive is active and means for maintaining a list of active primitives and updating the list by using the start row data to identify and add to the list any primitives first active in the new pixel row.

The start row data may comprise a list identifying for each pixel row any primitives first active in that row.

The apparatus may comprise means for generating and storing end row data identifying for each primitive the last pixel row in the series for which the primitive is active and means for deleting a primitive from the active primitive list when the plurality of intermediate pixel arrays for the last row have been rendered.

Means may be provided for maintaining a deleted primitive list identifying primitives deleted from the active primitive list which may yet be required to be treated as active in response to one or more of said offsets.

Each primitive primitive descriptor may include a pointer field for a pointer for a further primitive descriptor and wherein the active primitive list is formed for each row by using a succession of such pointers to link the active primitives together in a chain. The same pointer field may be used as part of the start row data field to link together in a chain two or more primitives which are first active in the same row. The same pointer field may also be used to link together in a chain the further subset of primitives.

An embodiment of the invention, from which the above and other features and advantages of the invention will become apparent, will now be described, by way of example, with reference to the accompanying drawings in which: Figure 1 shows in block schematic form apparatus for generating an image of objects in a three dimensional space for display on a two dimensional pixel array suitable for performing anti-alias filtering by multiple rendition, Figure 2 illustrates the principle of anti-alias filtering by multiple rendition, Figure 3 shows in block schematic form an embodiment of apparatus according to the invention for generating an image of objects in a three dimensional space for display on a two dimensional pixel array.

Figure 4 illustrates the principle of anti-alias filtering by multiple rendition in the apparatus of Figure 3, and Figures 5 and 6 show memory organisation within the apparatus shown in Figure 3.

Figure 1 shows schematically an apparatus for the display of images on a two dimensional display representing three dimensional objects. A data base module (OBJ) stores and manages a data base forming a model of a three dimensional environment, "the object space", containing various three dimensional objects, each modelled as a group of object primitives. Each primitive may, for example, be a polygonal surface or a curved patch which in ,turn is defined by a geometric description, for example vertex coordinates, and a surface description such as colour, texture, transparency, surface normal, etc. Geometric and surface descriptions of light sources may also be included. Another module (VEW) defines a viewing space, for example in terms of the position of a viewpoint, the direction of view and the field of view.

User input means (INP), such as a tracker ball, mouse and/or keyboard, are connected to a human computer interface module (HCI) which allows a user to manipulate or modify objects within the object space or to manipulate the view point, direction of view and other attributes of the viewing space. A geometry module (GEOM) performs geometric transformations to translate the various object space geometric descriptions of primitives defined in the data base module (OBJ) to equivalent descriptions in the viewing space. These transformations will generally include translation, rotation and perspective as is well known in the art. The surface descriptions of the primitives are also defined in accordance with lighting conditions in the viewing space.In the normal case where the image is only two dimensional, coordinates in the viewing space in 2-dimensions, typically called x and y, will correspond linearly to the screen coordinates, while a third coordinate z corresponds to the depth of the object into the screen.

The geometry module (GEOM) passes the viewing space primitive descriptors to a rendering module (DRW) which converts the viewing space primitive descriptions into a form suitable for display, typically by scan conversion into a 2-D array of pixel values in an image buffer memory (IMINT). The rendering module (DRW) may perform calculations for hidden surface removal, using the z coordinates, and for shading. Suitable means for performing such tasks are well known in the art.

In accordance with the multiple rendition technique described by Fuchs et al in the reference cited above, the pixel array in the buffer (IMINT) is an intermediate point of sampled image. For each image appearing on the display device (DIS) a set of N intermediate images are rendered and a module (OFFS) applies for each of the N renderings a different predetermined offset so that the sample point for each pixel moves between renderings. An image accumulator buffer (IMACC) adds together the intermediate images as they are generated so that after N renderings the image accumulator buffer (IMACC) contains an image which has been filtered in accordance with the sample point distribution and any weightings that may be attached to each sample point.

If successive refinements of the image are to be displayed as soon as they are available, as described by Fuchs et al then the values maintained in the buffer (IMACC) should be normalised so as to form a true running average of each rendition. If the buffer (IMACC) is double-buffered, however, the intermediate pixel values can simply be added together and divided by N after all renditions have been performed to obtain the final average, the final average value being read into the output stage of the double buffered image accumulator (IMACC).

In practice the offsets may be used to move the primitives relative to this stationary sample point array. For clarity, however, Figure 2 illustrates the reverse situation where a primitive P having an edge E and a vertex V remains stationary over a square array of pixel areas A, B, etc., while N equals sixteen different sub-pixel offsets affects point-sampling at points marked with dots within each of the two representative pixel areas A and B.

The sample point arrays shown for pixels A and B are identical and are repeated in every pixel area of the pixel array in accordance with a sub-pixel array defined by the set of N(=16) offsets. It can be seen that the sub-pixel array in Figure 2 is a simple example of sample points placed at the centres of a square grid of sixteen sub-pixels.

If it is assumed for simplicity that the shaded primitive P has a colour value of 1 and the background has a value of zero, it can be seen from Figure 2 that the final average value for pixel A will be seven sixteenths or eight sixteenths and that for pixel B will be five sixteenths or six sixteenths. These fractions represent the fraction of the pixel area covered by the primitive quantised in sixteenths of a pixel so that the image in the accumulator buffer (IMACC) is at least approximately anti-alias filtered.

Anti-aliasing is a problem which is more apparent on some features of an image than on others. In particular, an edge such as the edge E, which slopes very slightly with respect to the principle axes x and y of the pixel array, tends to generate very visible staircase effects. This is particularly disturbing in motion picture image sequences when the steps of the staircase appear to run at high speed along the edge E as it moves, for example to positions E' and E" in successive images.

Figure 2 shows how the sample grid pattern uses these potential sixteen quantisation levels inefficiently, particularly in the case described when aliasing is generally most obtrusive.

As the primitive edge E moves to position E' the filtered colour value remains constant at eight over sixteen. Then in the short space between E' and E" the value jumps four levels to twelve over sixteen. In effect, as the relevant edge approaches horizontal or vertical, the N(=16) quantisation levels potentially available are effectively reduced to only the jN(=4) so that twelve of the sixteen renditions are effectively made redundant in the situation where good filtering is most needed.

Our co-pending application No. 9 t..5 .t (PHB33649) discloses a novel series of sampling arrays which use the quantisation levels more efficiently by providing an array of points which are non-regular or which are regular but not aligned with the pixel rows so that projections of the points intersect the pixel axes at more than jN points. The present invention is equally applicable to the prior art regular sub-pixel arrays and to the special sub-pixel arrays disclosed in the above referenced co-pending application.

Figure 3 shows in block schematic form apparatus according to the invention for displaying images representing objects in a three dimensional space on a two dimensional display the images being generated by means of a scan line algorithm and is arranged to enable multiple rendition of the image for anti-alias filtering.

As with the apparatus shown in Figure 1, a data base module (OBJ) stores and manages a data base forming a model of a three dimensional environment, "the object space", containing various three dimensional objects each modelled as a group of object primitives. Another module (VEW) defines a viewing space, for example in terms of the position of a view point, the direction of view and the field of view. User input means (INP) such as a tracker ball, mouse and/or keyboard are connected to a human computer interface (HCI) to allow a user to manipulate or modify objects within the object space or to manipulate the view point, direction of view, and other attributes of the viewing space.A geometry module (GEOM) performs geometric transformations to translate the various object space geometric descriptions of primitives defined in the data base module (OBJ) to equivalent descriptions in the viewing space. These descriptions are stored in a primitive store (PST) which could form part of the geometry module (GEOM). A span generator (SPGN) and span processor (SPPR) together with the offset generator (OFGN) are equivalent to the modules (DRW) and (OFFS) of Figure 1.

The scan line algorithm generates an image one line at a time, typically from top to bottom. While processing a screen line, information about all the primitives, which in the embodiments described are polygons, which contribute to the line must be available. This is achieved by maintaining a linked list, called the active polygon list (APL), of all the contributing polygons. When moving from one screen line to the next some polygons will no longer be contributing to the image, so these must be deleted from the list. Others may now start to contribute and these must be added. The order in which polygons appear in the list is of no consequence. It is only necessary that the list is an exact record of all polygons which partially cover the current line.

To enable the active polygon list to be constructed a data table of all the two dimensional polygons that are going to make up the image is assembled before any pixels of that image are generated. This contrasts with non scan-line systems, such as that shown in Figure 1, where polygons may be processed one at a time from the three dimensional representation to two dimensional pixels. If the three dimensional polygons are sorted into buckets, one for each screen line, then the addition of new polygons to the active polygon list (APL) can be done simply by appending the appropriate bucket list onto the APL. Figure 5 shows this structure which is in the memory PST.

As shown in Figure 5, there is a memory bank 0,1, ...L which points to a bucket list of polygons which start on scan lines These y-buckets contain a linked list of polygons which start on a given line y. In Figure 5 it is shown that on line y=O two polygons start (lust and 2nd). For each polygon the start line (STY) and end line (EDY) are stored together with edge slopes and x values on the start line (which in the case of the triangular primitive shown in Figure 4 will be a single value). In addition depth values (z) and surface characteristics will be stored.

The basic algorithm for the scan generator (SPGN) to process one frame is as follows: for each y, if new entries in y-bucket add new entries to active polygon list for each polygon in active polygon list generate a span descriptor if line = EDY delete polygon from active polygon list else increment edges.

Thus after all the polygons have been sorted into y-buckets depending on their minimum y value, the span generator (SPGN) traverses the screen from minimum to maximum screen y, i.e. from top to bottom. For each line it transmits a span descriptor (SD), for every polygon present on that line to the span processor (SPPR) which draws the pixels into a single line image buffer (LIMINT) which stores intermediate pixel values. The span generator (SPGN) maintains a list of active polygons which is updated before processing each scan line. Typically, the polygons in the new y-buckets are added to the list and some old ones are deleted. Remaining old polygons have all the edge values incremented by their vertical slopes at this stage.

For any screen line y=L a bucket of linked polygons exists that terminate in a null pointer, that is a pointer which points to address zero. A processor in the span generator (SPGN) maintains the active polygon list. For the current line, it first adds the bucket L to the active polygon list to bring in polygons which start on this line by writing the start address of bucket L into the null pointer of the active polygon list, the null pointer of bucket L then forming the new null pointer of the active polygon list. It then traverses the active polygon list and for each polygon generates a span descriptor (SD) which includes information about the start and finish x values, depth or z-value, colour, lighting values, etc. This span descriptor is sent to a separate span processor (SPPR) which writes pixel values into the line buffer (LIMINT).If required, hidden surface removal may also be performed at this stage, for example, by means of the z-buffer algorithm. The span generator (SPGN) also increments the x-left and x-right values of each polygon descriptor by the appropriate slope value ready for the next screen line.

The amount of memory which must be allocated to the y-bucket polygon list depends on the total number of polygons in the scene and also on the complexity of the data structures. Sophisticated rendering algorithms with multiple texture maps will need much more storage capacity than simple Gouraud shaded polygons. The polygon list supports two different linked structures simultaneously, the y-bucket linked list and the active polygon linked list. However, the same pointer field can be used for both since they are never needed simultaneously.

There is an array in the memory having a size equal to the number of lines in the screen (0,1...L) containing entries which point to the y-buckets, that is the linked list of polygons which begin on each line. There is also a pointer, APL start, which points to the first polygon structure in the active polygon list (APL). This structure is used in maintaining the active polygon list (APL) and the only significant field of this structure is link pointer. The contents of the frame polygon memory before processing the first screen line is illustrated in Figure 5.

Initially the link pointer field of APL start points to null. The y-bucket entry for screen line zero points to a list of two polygons linked by their link pointer fields. The second polygon points to null. New y-buckets are added to the active polygon list at the start of every screen line. If a bucket is empty, the null link pointer of the last polygon will simply be overwritten with the null pointer from the bucket array entry.

According to the anti-alias filtering scheme disclosed by Fuchs et al, all the polygons in a frame are rendereed a number of times into a cumulative buffer, each rendition having a different pair of sub-pixel xoffsets and yoffsets. All x and y polygon vertex positions are processed and held to fractional accuracy. The result is a spatial filtering of the image with anti-aliasing effect. The scan line processing by definition happens on a line-by-line basis and although sub-pixel xoffsets can easily be dealt with, the yoffsets can cause one scan line to influence the next. This is not possible with the known scan line algorithm.

Figure 4 shows a triangular polygon shown in its normal position 1 and in two possible offset positions 2 and 3. For scan lines A to D, the new limits xleft and xright of the span can be computed for positions 2 and 3 from the offset values Nx and Ny. The Nx value is simply added to both xleft and xright and the Ny value is multiplied by the edge slopes to transform it into a horizontal offset before subtracting; that is xleft (new) = xleft + Nx - Ny oxleft, and xright (new) = xright + nx - ny dxright.

Each span is sent a number of times to the span processor (SPPR) with the xleft and xright values modified in accordance with each offset.

To achieve anti-alias filtering by multiple rendition it is necessary to send each span desciptor a number of times to the span processor (SPPR). For the horizontal (or x) offsets this poses no problems but for the vertical (or y) offsets a number of problems exist. In scan line A the scan can be reduced to zero or even a negative length by these offsets. The polygon strictly ends at line D but when it is offset to position 3 it is necessary to render it in line E also. The first problem may be overcome by detecting a zero or negative span and rejecting it either within or before applying it to the span processor (SPPR). The second problem is solved in this embodiment by keeping a deleted polygon list (DPL) as well as the active polygon list (APL). The deleted polygon list (DPL) is constructed by taking all the polygons deleted in the processing of the previous scan line.It is then erased after the next scan line and the deleted polygons of that next scan line are then stored. Thus the deleted polygon list comprises all those polygons deleted from the active polygon list in the preceding line.

Figure 6 shows the contents of the frame polygon memory for the processing of screen line L. It shows that the first and second polygons which started on line 0 finished on line L-1 and hence comprise the deleted polygon list DPL for line L. It should be noted that it is not necessary that the polygons start and finish on the same lines, for example if only the first polygon finished on line L-1 the deleted polygon list would contain only the first polygon and it would then output a null pointer instead of being linked to the second polygon. It can also be seen that two further polygons, third and fourth, start on line L and that these are added to the active polygon list APL. In this example these are the only two polygons in the active polygon list but again this is not necessary or even usual as other polygons which started in previous lines may still be present.In that case the third and fourth polygons would merely be added to the list by linking them to the null pointer of the previous y-bucket.

The high level algorithm executed by the span generator (SPGN) when performing anti-alias filtering by multiple rendition is as follows: for each y append new y-bucket to active polygon list select first offset for all renditions except last for all polygons in deleted polygon list generate span for all polygons in active polygon list generate span accumulate line buffer select next offset for all polygons in deleted list generate span erase deleted polygon list for all polygons in active list if first span of polygon fractionally increment polygon to next screen line else generate span increment polygon one screen line if last span of polygon append polygon to deleted polygon list accumulate line buffer transfer line accumulator to frame buffer The high level algorithm given above has to be qualified in certain respects to take account of the problems set out with regard to offsets in the y direction. The 'generate span' statements relating to the deleted polygon list are only performed if the vertical offset Ny + (the fractional part of EDY)) 1. This is the required condition to bring a portion of the polygon onto the current scan line.

Where two polygons are vertically adjacent it is necessary to avoid attempting to display them both on the screen line where they meet in an antialiased system in order to avoid errors which are noticeable in an otherwise smooth image. To achieve this in the present embodiment the first line of a polygon is not displayed. This gives the advantage of overcoming the problems that occur in applying the vertical offset to the first span of a polygon which starts at some fractional vertical position. The transformation which converts a vertical offset into a horizontal shift of xleft and xright goes wrong in those cases. That is, when the apex of a triangle is the first line xleft and xright swap over to produce a negative span length. It is, however, still necessary to deal with the case where a vertical offset causes the first span of a polygon tooccur on the next display row (or screen line). These spans can be detected and rejected using the following test which will apply on the screen line immediately after STY.

if (integer part of STY) =Y-1 and (fractional part of STY)+Ny > 1 then reject span.

This may be combined with the condition of never displaying the first line of a polygon to give the test if integer (STY+Ny)) Y then reject span.

Unlike the active polygon list (APL) which gradually evolves as screen lines are processed, the deleted poylygon list (DPL) is erased and rebuilt for each screen line. However, since no polygon can be present in both the active and deleted lists simultaneously, the same link pointer can be used in the polygon descriptor for both purposes.

In addition to generating spans from polygons, it is also necessary vertically to increment all the parameters of the polygons for each screen line. This may be done at the same time as the final rendition for each line is generated. The first n-1 renditions then invlolve simply generating spans for the current active (APL) and deleted (DPL) polygon lists. Each rendition is performed and stored in a line buffer (LIMINT) which is then added into a line accumulator (LIMACC). The final rendition involves first generating spans from the deleted polygon list (DPL) and then erasing the deleted polygon list (DPL) in preparation for its re-construction. The active polygon list (APL) is then processed, that is spans are generated and completed polygons are moved from the active polygon list (APL) to the new deleted polygon list (DPL).Finally, the line accumulater buffer (LIMACC) accumulated and the resulting anti-alias filtered image line is transferred from the line accumulator (LIMACC) to the frame buffer.

Another detail in the processing of the polygons which should be taken into account is that when vertically incrementing the xleft, xright, zleft etc. parameters, the correct values at integer pixel positions are wanted. Since the STY value of a polygon has a fractional part, the first vertical increment is used to synchronise the polygon to the integer y grid, that is it is incremented not by a whole screen line, but by 1- (the fractional part of a STY).

From reading the present disclosure, yet other variations will be apparent to persons skilled in the art. Such variations may involve other features which are already known in the design, manufacture and use of electronic graphics systems and component parts thereof and which may be used instead of or in addition to features already described herein. Although claims have been formulated in this application to particular combinations of features, it should be understood that the scope of the disclosure of the present application also includes any novel feature or any novel combination of features disclosed herein either explicitly or implicitly or any generalisation of one or more of those features which would be obvious to persons skilled in the art, whether or not it relates to the same invention as presently claimed in any claim and whether or not it mitigates any or all of the same technical problems as does the present invention. The applicants hereby give notice that new claims may be formulated to such features and/or combinations of such features during the prosecution of the present application or of any further application derived therefrom.

Claims (23)

1. A method of generating an image of objects in a three dimensional space in the form of a two dimensional regular pixel array comprising a series of rows of picture elements (pixels), the method comprising: a) generating and storing a plurality of primitive descriptors, each comprising a geometrical and surface description of a primitive of the desired image, b) using the sorted primitive descriptors to render a plurality of pointed sample intermediate pixel arrays while imposing for each such rendition a different pre-determined offset between the primitives and the sample points, and c) combining the plurality of intermediate pixel arrays to generate and store a corresponding filtered pixel array, characterised in that the intermediate pixel arrays are one dimensional arrays generated and combined in accordance with steps b) and c) sequentially for each pixel row in turn.

2. A method as claimed in Claim 1, further comprising for each new pixel row in the series the preliminary step (al) of identifying a subset of the primitives as being active for the new pixel row, the steps b) and c) of said method being performed so as to ignore the descriptors of primitives not in the active subset.

3. A method as claimed in Claim 2, comprising for each new pixel row the further preliminary step (a2) of identifiying a further subset of the primitives as being potentially active in the new row, depending on the said offset, the steps b) and c) being performed so as to treat as active primitives in the further subset selectively in response to each said offset.

4. A method as claimed in Claim 2 or Claim 3, wherein each step a) includes generating and storing start row data identifying for each primitive the first pixel row in the series for which the primitive is active while the step al) includes maintaining a list of active primitives and updating the list by using the start row data to identify and add to the list any primitives first active in the new pixel row.

5. A method as claimed in Claim 4, wherein the start row data comprises a list identifying for each pixel row any primitives first active in that row.

6. A method as claimed in Claim 3 wherein the step a) includes generating and storing end row data identifying for each primitive the last pixel row in the series for which the primitive is active and the step al) comprises deleting a primitive from the active primitive list when the plurality of intermediate pixel arrays for the last row have been rendered.

7. A method as claimed in Claim 6, wherein the step a2) comprises maintaining a deleted primitive list identifying primitives deleted from the active primitive list which may yet be required to be treated as active in response to one or more of said offsets.

8. A method as claimed in Claim 6 wherein each primitive descriptor includes a pointer field for a pointer for a further primitive descriptor and wherein the active primitive list is formed for each row by using a succession of such pointers to link the active primitives together in a chain.

9. A method as claimed in Claim 8, wherein the same pointer field is used as part of the start row data field to link together in a chain two or more primitives which are first active in the same row.

10. A method as claimed in Claim 8 or Claim 9, wherein the same pointer field is used to link together in a chain the further subset of primitives.

11. A method generating an image in the form of a two dimensional regular pixel array substantially as described herein with reference to Figures 3 to 5 of the accompanying drawings.

12. Apparatus for generating an image of objects in a three dimensional space for display on a two dimensional regular pixel array comprising a series of rows of picture elements (pixels), the method comprising: means for generating and storing a plurality of primitive descriptors, each comprising a geometrical and surface description of a primitive of the desired image, means for sorting the primitive descriptors and rendering a plurality of point sampled intermediate pixel arrays, means for imposing for each such rendition a different pre-determined offset between the primitives and the sample points, and means for combining the plurality of intermediate pixel arrays to generate and store a corresponding filtered pixel array, characterised in that the intermediate pixel arrays are one dimensional arrays.

13. Apparatus as claimed in Claim 12, further comprising means for identifying a subset of the primitives as being active for the new pixel row.

14. Apparatus as claimed in Claim 13, comprising means for identifiying a further subset of the primitives as being potentially active in the new row, depending on the said offset.

15. Apparatus as claimed in Claim 13 or Claim 14, further comprising means for generating and storing start row data identifying for each primitive the first pixel row in the series for which the primitive is active and means for maintaining a list of active primitives and updating the list by using the start row data to identify and add to the list any primitives first active in the new pixel row.

16. Apparatus as claimed in Claim 15, wherein the start row data comprises a list identifying for each pixel row any primitives first active in that row.

17. Apparatus as claimed in Claim 14 comprising means for generating and storing end row data identifying for each primitive the last pixel row in the series for which the primitive is active and means for deleting a primitive from the active primitive list when the plurality of intermediate pixel arrays for the last row have been rendered.

18. Apparatus as claimed in Claim 17, comprising means for maintaining a deleted primitive list identifying primitives deleted from the active primitive list which may yet be required to be treated as active in response to one or more of said offsets.

19. Apparatus as claimed in Claim 17 wherein each primitive primitive descriptor includes a pointer field for a pointer for a further primitive descriptor and wherein the active primitive list is formed for each row by using a succession of such pointers to link the active primitives together in a chain.

20. Apparatus as claimed in Claim 19, wherein the same pointer field is used as part of the start row data field to link together in a chain two or more primitives which are first active in the same row.

21. Apparatus as claimed in Claim 19 or Claim 20, wherein the same pointer field is used to link together in a chain the further subset of primitives.

22. Apparatus generating an image of objects in a three dimensional space for display on a two dimensional regular pixel array substantially as described herein with reference to Figures 3 to 5 of the accompanying drawings.

23. Any novel feature or novel combination of features disclosed herein either explicitly or implicitly whether or not it relates to the same invention as that claimed in any preceding claim.