AU768158B2 - A method of staged rendering - Google Patents

Description

S&F Ref: 562665

AUSTRALIA

PATENTS ACT 1990 COMPLETE SPECIFICATION FOR A STANDARD PATENT

ORIGINAL

Name and Address of Applicant: Actual Inventor(s): Address for Service: 4 9 0 0 4* 00% 0 Canon Kabushiki Kaisha 30-2, Shimomaruko 3-chome, Ohta-ku Tokyo 146 Japan David Christopher Smith Spruson Ferguson St Martins Tower,Level 31 Market Street Sydney NSW 2000 (CCN 3710000177) A Method of Staged Rendering Invention Title: 4 ASSOCIATED PROVISIONAL APPLICATION DETAILS [33] Country [31] Applic. No(s) AU PQ9252 [32] Application Date 08 Aug 2000 The following statement is a full description of this invention, including the best method of performing it known to me/us:- 5815c 1 A METHOD OF STAGED RENDERING Technical Field of the Invention The present invention relates generally to computer graphics and, in particular, to a method of rendering pages of graphic objects, using an intermediate edge-based graphics format. The invention also relates to a computer program product including a computer readable medium having recorded thereon a computer program for rendering pages of graphic objects, using an intermediate edge-based graphics format.

Background Art A user can utilise an application program running on a computer system to create documents consisting of pages, where each page can contain graphic objects such as text, lines, clipart and image data. A graphical user interface is typically provided by the native operating system of the computer system. The operating system also typically provides user authentication, processor scheduling, file management, memory *...management, device management, network management and process synchronisation.

Generally, a facility is provided by each application to render each page of a document on a downstream printer device. The user merely tells the application to print the current document on a specified printer device. The application then sends commands describing the graphic objects for each page using a graphics device interface layer of the native operating system. This layer creates graphics objects, which are passed to a printer driver of the specified printer device. The printer driver is hereinafter referred to as the graphics rendering system. The graphics rendering system generally forms part of a rendering module being one module of a number of modules making up the native operating system. Rendering modules can be entirely software based, or formed using combinations of software modules and specific rendering hardware.

Rendering is the process by which the graphic objects received from the graphics device interface layer are converted to pixels by the graphics rendering system. In most I:\562665.doc 2 conventional systems, rendering is a two stage process. The first stage is generally referred to as the compiling stage where each incoming graphic object is converted into a format that can be understood and executed by a target printer. The resulting object graphics format, consisting of all the graphic objects for a page, is referred to as a job.

The job is a computer program that has been written in the language of the rendering module. For example, a Postscript printer requires all graphic objects from a host operating system to be converted to a format that complies with the Postscript language.

The second stage is to pass the job to a printer, which then executes the program. The printer in turn generates pixels that are output through the printer head and onto a page.

In some cases, the object graphics format discussed above is constrained by an internal fixed-size instruction set and fixed-size data structures, which creates a logical upper bound on the number of graphic objects that can be added to a job at any one time.

Conventionally, a number of methods and combinations of same have been employed to overcome this problem. One such method reduces the number of graphic objects added to the intermediate job by means of optimisations. For example, recognising that a series of eoooo adjacent thin rectangles of gradually varying flat color can be replaced with a single rectangle consisting of a 2-point linear blend. Also an interference graph may be used to S recognise objects that are totally obscured by objects painted later. Those objects need not be sent to the compiler module. This method can dramatically reduce the number of objects in many cases, but still does not guarantee all pages can be optimised in this way so as to come under the limit set by the intermediate object graphic format.

Another method of overcoming the problem of a logical upper bound on the number of graphic objects that can be added to ajob at any one time, is to layer render on a whole page of graphic objects. In this case, when the maximum number of objects have been added to the job, the job is closed and the objects are rendered to a temporary frame store, the same size as the page. A new job can be created and this frame store is then I:\562665.doc 3 added as the first object, representing a background image, and the compiler module can continue to receive more objects for the page. If the job again reaches its maximum allowed number of objects, then this job can be rendered to a second temporary frame store and so on. Ideally, the frame-store should be compressed to reduce the total amount of memory required for the frame-store. For example an A3 page at 600dpi requires 200MB of memory if there is to be no compression. Noting that compression is unpredictable, some pages may not compress too well (eg. the above 200MB A3 page may not even compress to 100 MB, depending on the image data.). However, it is possible to use a lossy compression scheme instead, such as JPEG, but artefacts risk appearing on the page and this may therefore be an unsatisfactory solution. Similarly, the compression factor remains unpredictable.

Still another method of overcoming the problem discussed above is to render a page in bands. This is similar to a layer render on a whole page. In this case, the graphics rendering system can tell the graphics device interface to pass only those objects that appear in a band of a page at any one time. There is a performance penalty using this method in some graphics device interface layers. For each band, the graphics device may need to re-render the entire page of data, thus slowing down the system considerably.

Further, those systems that can send only the objects that appear in a band of a page, for graphics objects that span a band boundary, the graphics device interface must still pass S 20 the object twice (ie. once for each band). Still further, this method reduces the number of graphic objects, but does not guarantee that a layer render is no longer needed. It is also dependent on whether the graphics device interface is able to perform banding.

Still another method of overcoming the above mentioned problem is to increase the field sizes of the intermediate instruction fonnrmat and data structures, such that more objects can be added to the intermediate job. However, this is not always possible. For I:\562665.doc 4 example, if the instruction set has already been implemented inside existing hardware, then the instruction field sizes can not be changed.

Disclosure of the Invention It is an object of the present invention to substantially overcome, or at least ameliorate, one or more disadvantages of existing arrangements.

According to a first aspect of the invention, there is provided a method of rendering a page image, said image comprising a plurality of graphical objects, said method comprising the steps of: adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; S.rendering a predetermined image to said page image; and S-rendering said graphical objects corresponding to each of said sub-jobs, over said "predetermined image to form said page image, depending on said sequential order.

According to a second aspect of the invention, there is provided a method of f rendering a page image, said image comprising a plurality of graphical objects, said method comprising the steps of: S adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is associated with a sub-job; and I:\562665.doc rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

According to a third aspect of the invention, there is provided a method of rendering a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said method comprising the steps of: adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated :o I S"with one of said sub-jobs; rendering a predetermined image representing a blank image, to said page image; and rendering said associated outlines and fill for each of said graphical objects oo.ooi corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

According to a fourth aspect of the invention, there is provided an apparatus for rendering a page image, said image comprising a plurality of graphical objects, said apparatus comprising: adding means for adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; and I:\562665.doc 6 rendering means for rendering a predetermined image to said page image, and for rendering said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

According to a fifth aspect of the invention, there is provided an apparatus for rendering a page image, said image comprising a plurality of graphical objects, said apparatus comprising means for performing the following steps: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new oo I current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is V associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

According to a sixth aspect of the invention, there is provided an apparatus for rendering a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said apparatus comprising: adding means for adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; 1:\562665.doc 7 rendering means for rendering a predetermined image representing a blank image, to said page image, and for rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

According to a seventh aspect of the invention, there is provided an apparatus comprising: a memory for storing a program; and a processor for executing the program, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising: code for adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order S. such that each of said graphical objects is associated with one of said sub-jobs; code for rendering a predetermined image to said page image; and code for rendering said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

According to an eighth aspect of the invention, there is provided an apparatus comprising: a memory for storing a program; and a processor for executing the program, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising code for performing the steps of: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; I:\562665.doc 8 (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

According to a ninth aspect of the invention, there is provided an apparatus :o comprising: S"a memory for storing a program; and a processor for executing the program, said program being configured to render a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said program comprising: code for adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said subjobs being created in a sequential order such that each of said graphical objects is 20 associated with one of said sub-jobs; code for rendering a predetermined image representing a blank image, to said page image; and code for rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

I:\562665.doc 9 According to a tenth aspect of the invention, there is provided a program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising: code for adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; code for rendering a predetermined image to said page image; and code for rendering said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

According to an eleventh aspect of the invention, there is provided a program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising code for performing the following steps: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

I:\562665.doc According to a twelfth aspect of the invention, there is provided a program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said program comprising: code for adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said subjobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; code for rendering a predetermined image representing a blank image, to said page image; and code for rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

S"Brief Description of the Drawings One or more embodiments of the present invention will now be described with reference to the drawings and appendices, in which: Fig. 1 is a schematic block diagram of a general-purpose computer upon which 20 the embodiments of the present invention can be practiced; Fig. 2 shows the sequence of calls between a graphics device interface, the graphics rendering system and downstream printer device; Fig. 3 is a diagram of a page consisting of eight graphic objects; Figs. and show the contents of three sub-jobs in accordance with the example of Fig. 3; I:\562665.doc 11 Fig. 5(a) and show the edges of the first band of the first sub-job and the expected contents of the band-buffer after rendering the first band of first sub-job, in accordance with the example of Fig. 3; Figs. 6(a) and show the edges of the first band of the second sub-job and the expected contents of the band-buffer after rendering the first band of the second sub-job in accordance with the example of Fig. 3; Figs. 7(a) and show the edges of the first band of the third sub-job and the expected contents of the band-buffer after rendering the first band of the third sub-job, in accordance with the example of Fig. 3; Fig 8 shows the expected contents of the band-buffer after rendering the second band of the third sub-job, in accordance with the example of Fig. 3; Fig. 9 shows a page consisting of eight graphic objects including a transparent square and an opaque circle; Figs. 10(a), and show the contents of three sub jobs, in accordance with the example of Fig. 9; Figs. 11(a) and show the first band of the first sub-job and the expected contents of the band-buffer after rendering the first band of the first sub-job, in accordance with the example of Fig. 9; Figs. 12(a) and show the first band of the second sub-job and the expected o.o• contents of the band-buffer after rendering the second band of the first sub-job, in accordance with the example of Fig. 9; Fig. 13 shows the expected contents of the band-buffer after rendering the first band of the third sub-job, in accordance the example of Fig. 9; Figs. 14(a) and show the expected contents of the band-buffer after rendering the second band of the first sub-job, in accordance with the example of Fig. 9; I:\562665.doc 12 Figs. 15(a) and is a diagram showing the expected contents of the bandbuffer after rendering the second band of the second sub-job, in accordance the example of Fig. 9; Fig. 16 shows the expected contents of the band -buffer after rendering the second band of the third sub-job, in accordance with the example of Fig. 9; Fig. 17 is a flow diagram showing the overall process of rendering pages of graphics objects.

Fig. 18 is a flow diagram showing a method of rendering a page of graphics objects; Fig. 19 is a flow diagram showing a further method of rendering a page of graphics objects; •Appendix 1 is a description of the pseudo code, which can be used to perform the method of Fig. 18; and Appendix 2 is a description of the pseudo code, which can be used to perform the method of Fig. 19.

"Detailed Description including Best Mode Where reference is made in any one or more of the accompanying drawings to steps and/or features, which have the same reference numerals, those steps and/or features have for the purposes of this description the same function(s) or operation(s), unless the contrary intention appears.

Some portions of the description which follows are explicitly or implicitly presented in terms of algorithms and symbolic representations of operations on data within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps I:\562665.doc 13 are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

It should be borne in mind, however, that the above and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise, and as apparent from the following, it will be appreciated that throughout the present specification, discussions utilizing terms such as "scanning", "calculating", "determining", "replacing", "generating" "initializing", "outputting", or the like, refer to the action and processes of a computer system, or similar electronic device, that manipulates and transforms data represented as physical (electronic) quantities within the registers and memories of the computer system into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or ooooi display devices.

The present specification also discloses apparatus for performing the operations of the methods. Such apparatus may be specially constructed for the required purposes, or may comprise a general purpose computer or other device selectively activated or reconfigured by a computer program stored in the computer. The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus.

Various general purpose machines may be used with programs in accordance with the teachings herein. Alternatively, the construction of more specialized apparatus to perform the required method steps may be appropriate. The structure of a conventional general purpose computer will appear from the description below.

I:\562665.doc 14 In addition, the present specification also discloses a computer readable medium comprising a computer program for performing the operations of the methods. The computer readable medium is taken herein to include any transmission medium for communicating the computer program between a source and a designation. The transmission medium may include storage devices such as magnetic or optical disks, memory chips, or other storage devices suitable for interfacing with a general purpose computer. The transmission medium may also include a hard-wired medium such as exemplified in the Internet system, or wireless medium such as exemplified in the GSM mobile telephone system. The computer program is not intended to be limited to any particular programming language and implementation thereof It will be appreciated that a variety of programming languages and coding thereof may be used to implement the S•teachings of the invention as described herein.

Before proceeding with a description of the methods described herein, a brief ,a review of terminology is discussed. A computer program that is currently executing is called a 'process'. A given process may have one or more 'threads' of execution which is oo.

well known in the art. Threads are the mechanism by which an application can appear to be performing more than one task at a time so that two threads of a process may operate similtaneously. An 'instance' refers to an object created from a module. Multiple instances can share the same code but maintain a separate set of associated data.

*ooo A method of rendering pages of graphics objects, using an intermediate edgebased graphics format, is described below. The method of rendering is preferably practiced using a conventional general-purpose computer system 100, such as that shown in Fig. 1, wherein the method of rendering may be implemented as software, such as an application program executing within the computer system 100. In particular, the steps of method of rendering are effected by instructions in the software that are carried out by the computer. The software may be divided into two separate parts; one part for carrying out I:\562665.doc the first rendering method; and another part to manage the user interface between the latter and the user. The software may be stored in a computer readable medium, including the storage devices described below, for example. The software is loaded into the computer from the computer readable medium, and then executed by the computer. A computer readable medium having such software or computer program recorded on it is a computer program product. The use of the computer program product in the computer preferably effects an advantageous apparatus for performing the method of rendering in accordance with the embodiments of the invention.

The computer system 100 comprises a computer module 101, input devices such as a keyboard 102 and mouse 103, output devices including a printer 115 and a display device 114. A Modulator-Demodulator (Modem) transceiver device 116 is used by the computer module 101 for communicating to and from a communications network 120, for example connectable via a telephone line 121 or other functional medium. The ao...o modem 116 can be used to obtain access to the Intermet, and other network systems, such i.o.

as a Local Area Network (LAN) or a Wide Area Network (WAN).

The computer module 101 typically includes at least one processor unit 105, a memory unit 106, for example formed from semiconductor random access memory (RAM) and read only memory (ROM), input/output interfaces including a video interface 107, and an 1/O interface 113 for the keyboard 102 and mouse 103 and *oo.

20 optionally a joystick (not illustrated), an interface 108 for the modem 116. A storage device 109 is provided and typically includes a hard disk drive 110 and a floppy disk drive 111. A magnetic tape drive (not illustrated) may also be used. A CD-ROM drive 112 is typically provided as a non-volatile source of data. The components 105 to 113 of the computer module 101, typically communicate via an interconnected bus 104. Examples of computers on which the embodiment can be practised include I:\562665.doc 16 IBM-PC's and compatibles, Sun Sparcstations or alike computer systems evolved therefrom.

An application program implemented in accordance with the methods described herein is preferably resident on the hard disk drive 110 and read and controlled in its execution by the processor 105. The methods described herein are preferably part of a graphics rendering system also resident on the hard disk drive 110 that renders pages of a document into pixels and sends the pixels to a downstream device, such as the printer 115, via the 1/0 interface 108. As discussed above, the graphics rendering system is one of a number of software modules that together form the operating system of the computer system 100. Each page to be rendered can contain graphic objects in the form of text, lines, clipart and image data.

•Fig. 17 is a flow diagram showing a method 1700 of rendering pages of graphics objects in accordance with the arrangements of the present invention. The method 1700

SS...

is preferably resident on the hard disk drive 110 and read and controlled in its execution by the processor 105.

S" The method 1700 begins at the first step 1701, where each incoming graphics object is passed into a compiler module (not illustrated). The compiler module converts the graphic objects into a compact intermediate edge-based object graphics format in the form of a display list. Therefore, the input to the compiler module is in the form of graphic objects and the output is a display list, comprising edges and associated fills, and priorities.

The display list represents the job and contains all the information needed to render the page. The job preferably comprises a list of instructions and data, which define the page to be rendered. Each graphics object is preferably separated into the edges defining the object, associated fill (ie. flat colour, image data, tiled image data, blend, etc), raster operation (ie. a description of how the object is combined with the I:\562665.doc 17 objects underneath it) and priority or z-order. The objects preferably appear in an instruction stream in ascending y-order down the page, and in ascending x-order across the page to be rendered. This instruction stream format means that the first pixel output corresponds to the top-left-most pixel on the page, and the last pixel output corresponds to the bottom right-most pixel on the page.

At the next step 1703, the commands within the job are interpreted to render the page a scan-line at a time, preferably into a frame-store which is part of the hard disk drive 110. This task is preferably performed by a rendering module (not illustrated) of the operating system for the computer system 100. Rendering occurs only within the edges of the graphics object to be rendered. Data is generated pixel by pixel by determining which objects are visible for each pixel based on the objects z-order, and then generating the pixel colour from the visible objects. When the first instruction is executed toss S. the instruction will correspond to the edges of the object that appears at the top/left-most position of the page for the first scanline, regardless of the priority of the object. Further instructions on this scanline correspond to objects appearing to the right of the current object, but no higher than this, until the next scanline is rendered.

The rendering module is passed a buffer (not illustrated) into which it writes *a.

rendered pixel data. The buffer [hereinafter referred to as a band buffer] preferably has a width the size of the page, but the height can correspond to any number of scanlines a 0o 060* 20 band). The rendering module keeps state between invocations, so that it can be invoked multiple times, until the entire page is rendered. The rendering module is preferably instructed to write white pixels where no graphic objects appear. Alternatively, the rendering module can be instructed to write only the pixel data of graphic objects and assume that the buffer into which it is writing has been previously initialised with whitespace. The pixels in each band can be output through a print head and onto a physical page.

I:\562665.doc 18 Fig. 2 shows the progression of data and sequence of calls, numbered sequentially from 1 to 14, between an application program 201 (eg. a word processing application) running on the system 100, the graphics device interface 203, the graphics rendering system 205 and the downstream printer device 115, in accordance with the methods described herein. As discussed above, the intermediate object graphics format is typically constrained by an internal fixed-size instruction set and fixed-size data structures. There is therefore an upper bound to the number of graphic objects that can be added to ajob at any one time.

Fig. 18 is a flow diagram showing a method 1800 of rendering a page of graphic objects. The method 1800 is preferably resident on the hard disk drive 110 and read and controlled in its execution by the processor 105.

.o.o In accordance with the method 1800, a renderer (not shown) only renders the .pixels for those graphic objects appearing in each sub-job, and each time the resulting pixel image is stored in a band-buffer. The method 1800 is particularly advantageous where the graphics device interface layer of the computer system 100 only requires a source-copy raster operation and does not support alpha blending. As explained above with reference to Fig. 17, the method 1800 of rendering as described herein is a two stage ,.OO process. The first stage comprises steps 1801 to 1807 and 1817 where a series of intermediate sub-jobs are constructed, such that each sub-job has as many graphic objects :#°ooo G 20 as can be held within the constraints of its internal fixed size instruction set. The method 6496 1800 begins at step 1801, where each incoming graphic object is converted to its constituent edges and associated fill in terms of the intermediate object graphics format.

At the next step 1803, the constituent edges and associated fill for the current object is added to a current intermediate sub-job. At the next step 1817, a check is performed to determine if the current intermediate sub-job has reached its internal limits. If step 1817 returns false then the method 1800 returns to step 1801. Otherwise the method 1800 I:\562665.doc 19 continues at the next step 1805, where the current intermediate sub-job is closed and a new intermediate sub-job is created. The new intermediate sub-job becomes the next current intermediate sub-job. At the next step 1807, a check is performed to determine if all the graphic objects for the page have been received. If all the graphic objects for the page have not been received at step 1807, then the method 1800 returns to step 1801.

Otherwise, the method 1800 proceeds to step 1809. Steps 1801 to 1807 and step 1817 continue whereby incoming graphic objects are received and new intermediate sub-jobs are created, such that a sequence of intermediate sub-jobs is accumulated, until all the graphic objects for the page have been received.

In accordance with the method 1800, the second stage comprises steps 1809 to 1815 and step 1819 where the accumulated intermediate sub-jobs are rendered in the same sequence in which they were created, such that only the pixels for a band of the page are rendered into a band-buffer at any one time. At the next step 1809, a renderer instance is associated with each sub-job. At the next step 1811, the band-buffer is initialised with white pixels, representing a blank page. Alternatively, the band-buffer can •be initialised to any bit-map image. For example, the band-buffer can be initialised to a company logo, an advertising banner, a textured background or an image depicting 'Buffy **the Vampire Slayer'. The method 1800 continues at the next step 1813, where the next sub-job is rendered into the band-buffer, such that only the pixels associated with each graphic object contained within the current sub-job are written into the band buffer. At the next step 1815, a check is performed to determine if all sub-jobs have been rendered.

If all sub-jobs have not been rendered, then the method 1800 returns to step 1813.

Otherwise, the method 1800 proceeds to step 1819 to determine if the entire page has been rendered. If the entire page has not been rendered then the method 1800 returns to step 1811. Otherwise, the method 1800 concludes. Therefore, in accordance with the method 1800, when the last sub-job has been rendered for a band, the band-buffer I:\562665.doc contains all the pixel data for that band of the page. The graphics rendering system 205 can then send the pixels stored in the band-buffer to the downstream printer device 115.

Any remaining bands for the page are rendered in the same manner by repeating steps 1811 to 1815 and 1819.

The method of rendering pages of graphics objects, in accordance with the method 1800, will now be described with reference to an example illustrated in Figs. 3 to 8. Fig. 3 shows a page 300 of eight graphic objects 301-308 with each object having a different colour. In accordance with the example of Figs. 3 to 8, the page 300 comprises a red character referenced as 301, a striped black/white B 307, a yellow C 304, a black D 306, a green E 303, a black F 308, an orange square 302 and a grey circle 305.

As seen in Fig. 3, for the purpose of the following description, the colours of the graphic objects 301 to 308 are represented by different fills as Figs. 3 to 8 are gray scale drawings. For example, the orange square 302 is represented by black dots on a white i' background.

The page 300 is to be rendered in two bands 309, 310 as required by the downstream printer device 115. The graphic objects 301-308 are received by the compiler module (not shown) of the computer system 100 in the following order: 301,307, 304, 306, 303,308, 302, 305.

As the compiler module receives the graphic objects 301-308, the objects are converted into their constituent edges and associated fill and added to a current sub-job, as at steps 1801 and 1803 of Fig. 18. In accordance with the example of Figs. 3 to 8, by the third object 304, no more objects can be received. The current sub-job is closed and a new sub-job is created, as at step 1805 of Fig. 18. The compiler module then receives and converts three more graphic objects 306, 303, 308. Again, by the third I:\562665.doc 21 object 308, no more objects can be received. The current sub-job is closed and a new sub-job is started. Therefore, steps 1801 to 1807 of Fig. 18 are repeated.

The compiler module then receives and converts the remaining graphic objects 302, 305. After the second object (circle) 305 is added, the graphics rendering system 205 is told to send the page to the printer 115, indicating that there are no more graphic objects to come, so the third sub-job is closed.

The first 401, second 403 and third 405 sub-jobs are shown in Figs respectively. In accordance with the example of Figs. 3 to 8, the printing device 115 only has enough memory to receive a buffer of '128' scanlines at a time. Since the page is 256 scanlines high, the graphics rendering system 205 must send the pixel data to the printer 115 in two bands. Before rendering the first band, the graphics rendering system creates three instances of the rendering module one for each sub-job 401 405) and passes the associated sub-job into the instance, as at step 1809 of Fig. 18. In accordance with the ,methods described herein, multiple instances of the renderer module can coexist in one S 15 thread and the renderer and compiler modules execute in a single thread.

Figs. 5(a) and show the edges of the first band 503 of sub-job 401 and the contents of the band-buffer 501 after rendering the first band 503 of sub-job 401. As shown in Figs. 5(a) and the graphics rendering system 205 initialises the band-buffer 501 to white pixels, as at step 1811, representing a blank page and then invokes the first renderer instance, passing in the band-buffer 501, and instructing the rendering module to render 128 scanlines of pixel data (ie. scanlines 0-127), as at step 1813. Edges start at scanline Y1 as seen in Fig. The renderer module of the computer system 100 moves to edge Al and begins to output red pixels until it reaches edge A2. In accordance with the example of Figs. 3 to 8, the renderer module then skips to edge C 1 and outputs yellow pixels until it reaches edge C2. The renderer module continues to process edges until I:\562665.doc 22 scanline Y2, as no more edges appear in this band 503. The band-buffer 501 now contains characters 301 and 304.

Figs. 6(a) and 6(b) show the edges of the first band 603 of sub-job 403 and the contents of the band-buffer 501 after rendering the first band of sub-job 403. In accordance with the example of Figs. 3 to 8, after rendering the first band 503 of sub-job 401, the graphics rendering system 205 invokes the second renderer instance, passing in the band-buffer 501, instructing the renderer module to render 128 scanlines of pixel data.

Edges start at scanline Y1, as seen in Fig. The rendering module moves to edge El and outputs green pixels until it reaches edge E2. The renderer module of the computer system 100 continues to process edges until scanline Y2, as no more edges appear in this band. In accordance with the example of Figs. 3 to 8, the band buffer now contains characters 301, 303 and 304, as seen in Fig.6(b).

0: :.Figs. 7(a) and 7(b) show the edges of the first band 703 of sub-job 405 and the .•contents of the band-buffer 501 after rendering the first band 703 of sub-job 405. After rendering the first band 603 of sub-job 403, the graphics rendering system 205 invokes the third renderer instance, passing in the band-buffer 501, instructing the renderer to render 128 scanlines of pixel data. Edges start at scanline Y3, as seen in Fig. The rendering module moves to edge S1 and outputs orange pixels until the rendering module reaches edge S2. The rendering module continues to process edges until scanline 127, since edges C1 and C2 are still active. After rendering the first band 703 of sub-job 405 the graphics rendering system 205 has successfully rendered the first band 309 of the page 300 to the band-buffer 501. In accordance with the example of Figs. 3 to 8, the graphics rendering system 205 then sends the pixels stored in the band-buffer 501 to the downstream printer device 115.

To render the second band 310 of the page 300, as seen in Fig. 8, the graphics rendering system 205 re-initialises the band-buffer 501 to white pixels and then invokes I:\562665.doc 23 the first renderer instance, passing in the band-buffer 501, instructing the rendering module to render the next 128 scanlines of pixel data (ie. scanlines 128-255).

Alternatively, the band-buffer 501 can be initialised to something different for the second band 310 of the page 300, other than white pixels. The band-buffer 501 can be initialised to any bitmap image. After rendering the second band 310 of the page 300 to the band buffer 501, the graphics rendering system 205 sends the pixels stored in the band-buffer 501 to the downstream printer device 115.

Fig. 19 is a flow diagram showing a further method 1900 of rendering a page of graphics objects. The method 1900 is preferably resident on the hard disk drive 110 and read and controlled in its execution by the processor 105.

The method 1900 can be utilised where a graphics device interface layer (e.g.

203) does support raster operations and/or transparency. In accordance with the method 1900, the results of previous sub-jobs are included in the instruction stream of subsequent sub-jobs, thus providing the rendering module access to the pixel data of the previous S 15 sub-jobs. The method 1900 is suitable where complex raster operations and transparent blend operations must be supported by the graphics rendering system 205. As explained above with reference to Fig. 17, the method 1900 of rendering as described herein is a *.two stage process. The first stage comprises steps 1901 to 1907 and step 1921, where a series of intermediate sub-jobs are created, such that each sub-job has as many graphic objects as can be held within the constraints of its internal fixed size instruction set.

The method 1900 begins at step 1901, where each incoming graphic object is converted to its constituent edges and associated fill in terms of the intermediate object graphics format. At the next step 1903, the constituent edges and associated fill for the current object is added to a current intermediate sub-job until the current intermediate sub-job. At the next step 1921, a check is performed to determine if the current intermediate sub-job has reached its internal limits. If the current intermediate sub-job has I:\562665.doc 24 not reached its internal limits at step 1921, then the method 1900 returns to step 1901.

Otherwise, the process proceeds to the next step 1905, where the current intermediate sub-job is closed and a new intermediate sub-job is created. The new intermediate subjob becomes the next current intermediate sub-job. At the next step 1907, a tiled bitmap is added as the first graphic object of the next current intermediate sub-job that spans the entire page and where the actual tile is the size of a band. The method 1900 continues at the next step 1909, where the previous sub-job and a pointer to the fill-data for the most recently added tiled-bitmap are stored. At the next step 1911, a check is performed to determine if all the graphic objects for the page have been received. If all the graphic objects for the page have not been received at step 1911, then the method 1900 returns to step 1901. Otherwise, the method 1900 proceeds to step 1913. Steps 1901 to 1911 and 1921 continue whereby incoming graphic objects are received and new intermediate subjobs are created, such that a sequence of intermediate sub-jobs is accumulated, until all •the graphic objects for the page have been received.

15 The second stage of the method 1900 comprises steps 1913 to 1919 and step 1923, where the accumulated intermediate sub-jobs are rendered in the same sequence in which they were created. At step 1913, a renderer instance is associated with each subjob. The method 1900 continues at the next step 1915, where the next sub-job is rendered into the fill-data of the tiled-bitmap for the subsequent sub-job. At the next step 1917, a check is performed to determine if all sub-jobs up-to and including the second-to-last subjobs have been rendered. If all sub-jobs up to and including the second-to-last sub-jobs have not been rendered, then the method 1900 returns to step 1915. Otherwise, the method 1900 proceeds to step 1919, where the last sub-job is rendered into the bandbuffer. Therefore, when the last sub-job has been rendered for the current band, the bandbuffer contains all the pixel data for that band of the page. In accordance with the method 1900, the graphics rendering system 205 can then send the pixels stored in the band- I:\562665.doc buffer to the downstream printer device 115. At the next step 1923, a check is performed to determine if the entire page has been rendered. If the entire page has not been rendered at step 1923, the process returns to step 1915. Otherwise, the process concludes.

The method 1900 of rendering pages of graphics objects, will now be described with reference to an example illustrated in Figs. 9 to 16. Fig. 9 shows a page 900 of eight graphic objects 901-908 with each object having a different colour. In accordance with the example of Figs. 9 to 16, the page comprises a red A 901, a striped black/white B 906, a yellow C 904, a black D 905, a green E 903, a black F 908, a transparent square 902 and an opaque grey circle 907. Again, for the purpose of the following description, the colours of the graphic objects 901 to 908 are represented by different fills as Figs. 9 to 16 are gray scale drawings. In accordance with the example of Figs. 9 to 16, the printing device 115 only has enough memory to receive a buffer of 128 scanlines at a time and the page 900 is 256 scanlines high. Therefore, the page 900 is to be rendered in two bands 910 as required by the downstream printer device 115. The graphic objects 901-908 are received by the compiler module (not illustrate) of the computer system 100 in the following order: ~901,906, 904, 905,903,908, 902, 907.

As the compiler module receives the graphic objects 901-908 the objects are converted into constituent edges and associated fill and added to the first sub-job 1001 seen in Fig.

as at steps 1901 and 1903 of Fig. 19. By the third object 904, no more objects can be received and the first sub-job 1001 is closed and the second sub-job 1002 seen in Fig. 10(b) is started, as at step 1905 of Fig. 19.

In accordance with example of Figs. 9 to 16, the first graphic object added to the second sub-job 1002, as at step 1907, is an empty tiled bitmap (shown in grey in Fig.

I:\562665.doc 26 spanning the width and the height of the page 900, where the actual tile is 128scanlines high, corresponding to the height of a band. The compiler module preferably receives a pointer to the fill-data for this tiled-bitmap, as at step 1909.

The compiler module then receives and converts the three graphic objects 903, 905 and 908. By the third object 908, no more objects can be received. The sub-job 1002 is closed and sub-job 1003 seen in Fig. 10(c), is started. Therefore, steps 1901 to 1911 of Fig. 19 are repeated.

The first graphic object added in sub-job 1003 seen in Fig. 10(c), is an empty tiled bitmap (shown in grey in Fig. 10(c)) spanning the width of the page 900, where the tile is 128-scanlines high, corresponding to the height of a band, and the compiler module gets a pointer to the fill-data for this tiled-bitmap. The compiler module receives and converts the remaining graphic objects 902 and 907. In accordance with the example of Figs. 9 to 16, after the second object (circle) 907 is added, the graphics rendering system 205 is told by the operating system of the computer system 100 to send the page to the S 15 printer 115. This indicates that there are no more graphic objects to come, so the sub-job 1003 is closed. The grey areas in sub-job 1002 and 1003, seen in Fig 10(b) and Fig.

respectively, correspond to the fill-data of the actual tiled image in each sub-job.

In accordance with the example of Figs. 9 to 16, before rendering the first band 909 of the page 900, the graphics rendering system 205 creates three instances of the rendering module (i.e one for each sub-job 1001, 1002 and 1003), and passes each subjob into the associated instance, as at step 1913 of Fig. 19. The graphics rendering system 205 then invokes the first renderer instance, passing in the pointer to the fill-data for subjob 1002 as the location to receive the pixel data. The graphics rendering system 205 instructs the rendering module to render 128 scanlines of pixel data (scanlines 0-127), as at step 1915 of Fig. 19.

I:\562665.doc 27 The tiled image of sub-job 1002, which has not yet been rendered, now contains the output from the first band 1101 of sub-job 1001 seen in Fig. 11(a). The tiled image spans the entire page 900. So if the entire page 900 were to be rendered to the printer device 115 at this point, the letters 901 and 904 would appear in both bands 909, 910 of the page 900, as seen in Fig. l The graphics rendering system 205 then invokes the second renderer instance, passing in the pointer to the fill-data for sub-job 1003 as the location to receive the pixel data. The graphics rendering system 205 instructs the renderer to render the first 128 scanlines of pixel data (scanlines 0 127).

Therefore, step 1915 is repeated.

The tiled image of sub-job 1003, which has not yet been rendered, now contains the output from the first band 1102 of sub-job 1002, seen in Fig. 12(a). The tiled image spans the entire page 900. So if the entire page 900 were to be rendered now, the letters A, C and E would appear in both bands 909 and 910 of the page 900, as seen in Fig.

12(b). In accordance with the example of Figs. 9 to 16, the graphics rendering system 205 then invokes the third renderer instance, passing in the band-buffer 501 as the location to receive the pixel data. The graphics rendering system 205 instructs the rendering module to render the first 128 scanlines of pixel data (scanlines 0 127), as .o.o seen in Fig. 13. At this point the graphics rendering system 205 has now successfully rendered the first band 909 of the page 900 and sends the pixels stored in the band-buffer 501 to the downstream printer device 115.

The graphics rendering system 205 then invokes the first rendering module instance, passing in the pointer to the fill-data for the sub-job 1002 as the location to receive the pixel data. The graphics rendering system 205 instructs the rendering module to render the next 128 scanlines of pixel data (scanlines 128-255). The tiled image of sub-job 1002, which has not yet been rendered, now contains the output from the second band 1103 of sub-job 1001, as seen in Fig. 14(a). The tiled image is the size of the page I:\562665.doc 28 900. So if the entire page 900 were to be rendered to the printer device 115 at this point, the letter 906 would appear in both bands 909, 910 of the page 900, as seen in Fig.

14(b).

The graphics rendering system 205 then invokes the second render instance, passing in the pointer to the fill-data for sub-job 1003 as the location to receive the pixel data. The graphics rendering system 205 instructs the rendering module to render the next 128 scanlines of pixel data (scanlines 128- 255). The tiled image of sub-job 1003, which has not yet been rendered, now contains the output from the second band 1104 of sub-job 1002, as seen in Fig. 15(a). The tiled image is the size of the page 900. So if the entire page 900 were to be rendered to the printer device 115 at this point, the letters (B) 906, 905 and 908 would appear in both bands 909, 910 of the page 900, as seen in Fig. The graphics rendering system 205 then invokes the third renderer instance, passing in the band-buffer 501 as the location to receive the pixel data. The graphics rendering system 205 instructs the rendering module to render the next 128 scanlines of pixel data (scanlines 128 255). At this point the graphics rendering system 205 has now successfully rendered the second band 910 of the page 900, as seen in Fig. 16, and the **"pixels stored in the band-buffer 501 can be sent to the downstream printer device 115.

As seen in Fig. 10(c), the sub-job 1003 contains a transparent square 902. When "20 the square 902 is over the A 901, the rendering module can read the red pixels of the A 901 from the tiled bitmap. If, for example, the square 902 is partially transparent the rendering module can composite the red pixels of A 901 with the partially transparent pixels of the square 902, writing the result into the band-buffer 501.

The aforementioned preferred methods comprise a particular control flow. There are many other variants of the preferred methods which use different control flows I:\562665.doc 29 without departing from the spirit or scope of the invention. Furthermore one or more of the steps of the preferred methods may be performed in parallel rather sequential.

Intermediate storage of an application program implemented in accordance with the methods described herein and any data fetched from the network 120 may be accomplished using the semiconductor memory 106, possibly in concert with the hard disk drive 110. In some instances, the application program may be supplied to the user encoded on a CD-ROM or floppy disk and read via the corresponding drive 112 or 111, or alternatively may be read by the user from the network 120 via the modem device 116.

Still further, the software can also be loaded into the computer system 100 from other computer readable medium including magnetic tape, a ROM or integrated circuit, a magneto-optical disk, a radio or infra-red transmission channel between the computer module 101 and another device, a computer readable card such as a PCMCIA card, and the Intemrnet and Intranets including email transmissions and information recorded on websites and the like. The foregoing is merely exemplary of relevant computer readable mediums. Other computer readable mediums may be practiced without departing from the scope and spirit of the invention.

The methods of rendering as described herein may alternatively be implemented in dedicated hardware such as one or more integrated circuits performing the functions or sub functions of Figs. 18 and 19. Such dedicated hardware may include graphic processors, digital signal processors, or one or more microprocessors and associated memories.

The foregoing describes only some arrangements of the present invention, and modifications and/or changes can be made thereto without departing from the scope and spirit of the invention, the arrangements being illustrative and not restrictive. For example, rather than initialising the band-buffer 501 to white pixels, as in the example of Figs. 3 to 8, the entire band associated with the first sub-job can be rendered to the band- I:\562665.doc 30 buffer 501. In this instance, for subsequent sub-jobs associated with a particular band, a rendering module only renders the pixels for those graphic objects appearing in each subjob.

In the context of this specification, the word "comprising" means "including principally but not necessarily solely" or "having" or "including" and not "consisting only of". Variations of the word comprising, such as "comprise" and "comprises" have corresponding meanings.

ee I:\562665.doc 31 APPENDIX 1 ARRAY sub-job[0-n] ARRAY renderer-instance[0-n] Sub-job creation phase CREATE new sub-job SET n 0

REPEAT

CONVERT incoming graphic object to intermediate object graphic format.

ADD converted object to sub-job.

IF sub-job can not hold any more objects CLOSE sub-job SET sub-job[n] sub-job SET n n 1 CREATE new sub-job

S...ENDIF

UNTIL all the page data has been received.

'Rendering phase FOR each sub-job[i] SET renderer-instance[i] CREATE new renderer instance for sub-job[i] END FOR

REPEAT

SET band-buffer WHITE I:\562665.doc 32 FOR sub-job[i], [O<=Kn] RE'-.N DER(reniderer- instanice[i 3, band-buffer, 128) END FOR 'Post Condition: 'band-buffer contains the pixels for this band of the page.

UNIL the page has been rendered.

I:\562665 .doc 33 APPENDIX 2 ARRAY sub-job[0-n] ARRAY renderer-instance0-n] ARRAY fill-data[0-n] Sub-job creation phase CREATE new sub-job SET n 0 SET band-height 128

REPEAT

CONVERT incoming graphic object to intermediate object graphic format.

ADD converted object to sub-job.

IF sub-job can not hold any more objects 15 CLOSE sub-job SET sub-jobln] sub-job SET n n CREATE new sub-job ADD tiled-image at (page-width x page-height) WITH tile size (page-width x band-height) TO sub-job SET fill-data[n] pointer to tiled-image fill data END IF UNTIL all the page data has been received.

Rendering phase I:\562665.doc 34 FOR each sub-job[i] SET renderer-instanefi] =CREATE new renderer instance [Ior SUb-Iob[i] END FOR

REPEAT

FOR subjob[i], [0 i <ri-i] REN.DER(reniderer-instanece[i], fill-d-ata[i .1 band-height) END FOR REN DE R(render-i n stance[nii- band-bu ffer, band-height) 'Post Condition.: band-buffer contains the pixels for this band of'the page.

UNTIL the page has been rendered.

I:\562665.doc

Claims (44)

1. A method of rendering a page image, said image comprising a plurality of graphical objects, said method comprising the steps of: adding said graphical objects to a plurality of sub-jobs depending on a (predetemined limit of said sbJbs, said sub-jobs being created in a sequential order such that each of said graphical objects is ssociate with one of said sub-jobs; rendering a predetermined image to said page image; and rendering said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

2. The method according to claim 1, wherein said predetermined image is a band of said page image. 15

3. The method according to claim 1, wherein said sub-jobs are rendered in said sequential order.

4. The method according to claim 1, wherein said predetermined image represents a blank page.

The method according to claim 1, wherein said predetermined image is an advertising banner.

6. The method according to claim 1, wherein said predetermined image is a company logo. I:\562665.doc 36

7. The method according to claim 1, wherein said predetermined image is a bitmap image.

8. The method according to claim 1, wherein said predetermined image is different for each band of said image.

9. The method according to claim 1, wherein said sub-job represents an intermediate set of instructions for rendering a portion of said page image.

10. A method of rendering a page image, said image comprising a plurality of graphical objects, said method comprising the steps of: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; 0 0. (ii) closing said current sub-job and creating a new current sub-job, upon 000 0: 15 reaching said predetermined limit; S(iii) adding a predetermined image as a first graphic object of said new 000*current sub-job, wherein said predetermined image has a predetermined size; S. (iv) repeating steps to (iii) until each of said graphical objects is *9 associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs 96*9 in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

11. The method according to claim 10, wherein said predetermined image is a band of said page image. I:\562665.doc 37

12. The method according to claim 10, wherein said predetermined image is a tiled image.

13. The method according to claim 10, wherein said predetermined image represents a blank page.

14. The method according to claim 10, wherein said predetermined image is an advertising banner.

15. The method according to claim 10, wherein said predetermined image is a company logo. **get:

16. The method according to claim 10, wherein said predetermined image is a bitmap image.

17. The method according to claim 10, wherein said predetermined image is different for each band of said image.

18. A method of rendering a page image, said image comprising a plurality of 20 graphical objects, each said object having an associated predetermined outline and fill, said method comprising the steps of: adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; I:\562665.doc 38 rendering a predetermined image representing a blank image, to said page image; and rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

19. An apparatus for rendering a page image, said image comprising a plurality of graphical objects, said apparatus comprising: adding means for adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; and 0.. rendering means for rendering a predetermined image to said page image, and for rendering said graphical objects corresponding to each of said sub-jobs, over said 0 15 predetermined image to form said page image, depending on said sequential order. The apparatus according to claim 19, wherein said sub-jobs are rendered in said sequential order.

20

21. The apparatus according to claim 19, wherein said predetermined image represents a blank page.

22. The apparatus according to claim 19, wherein said predetermined image is an advertising banner. I:\562665.doc 0 39

23. The apparatus according to claim 19, wherein said predetermined image is a company logo.

24. The apparatus according to claim 19, wherein said predetermined image is a bitmap image.

The apparatus according to claim 19, wherein said predetermined image is different for each band of said image.

26. The apparatus according to claim 19, wherein said sub-job represents an intermediate set of instructions for rendering a portion of said page image.

27. An apparatus for rendering a page image, said image comprising a plurality of graphical objects, said apparatus comprising means for performing the following steps: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job. I:\562665.doc

28. The apparatus according to claim 27, wherein said predetermined image is a tiled image.

29. The apparatus according to claim 27, wherein said predetermined image represents a blank page.

The apparatus according to claim 27, wherein said predetermined image is an advertising banner.

31. The apparatus according to claim 27, wherein said predetermined image is a company logo.

32. The apparatus according to claim 27, wherein said predetermined image is a bitmap image. ooeo•

33. The apparatus according to claim 27, wherein said predetermined image is S"different for each band of said image. 20

34. An apparatus for rendering a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said apparatus comprising: adding means for adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; I:\562665.doc 41 rendering means for rendering a predetermined image representing a blank image, to said page image, and for rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

An apparatus comprising: a memory for storing a program; and a processor for executing the program, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising: code for adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; V code for rendering a predetermined image to said page image; and code for rendering said graphical objects corresponding to each of said sub-jobs, S: i over said predetermined image to form said page image, depending on said sequential order.

36. An apparatus comprising: a memory for storing a program; and a processor for executing the program, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising code for performing the steps of: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; I:\562665.doc 42 (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

37. An apparatus comprising: a memory for storing a program; and S".o°a processor for executing the program, said program being configured to render a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said program comprising: code for adding said associated outline and fill for each of said graphical objects a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub- jobs being created in a sequential order such that each of said graphical objects is .6 20 associated with one of said sub-jobs; code for rendering a predetermined image representing a blank image, to said page image; and code for rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order. I:\562665.doc 'm 43

38. A program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program comprising: code for adding said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub-jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; code for rendering a predetermined image to said page image; and code for rendering said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

39. A program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program .°comprising code for performing the following steps: adding at least one of said graphical objects to a current sub-job depending on a predetermined limit of said current sub-job; (ii) closing said current sub-job and creating a new current sub-job, upon reaching said predetermined limit; (iii) adding a predetermined image as a first graphic object of said new current sub-job, wherein said predetermined image has a predetermined size; (iv) repeating steps to (iii) until each of said graphical objects is associated with a sub-job; and rendering said graphical objects corresponding to each of said sub-jobs in a sequential order to form said page image, wherein each of said rendered sub-jobs, except for a last sub-job in said sequential order, includes graphical objects from a previous sub-job.

I:\562665.doc 44 A program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, each said object having an associated predetermined outline and fill, said program comprising: code for adding said associated outline and fill for each of said graphical objects to a plurality of sub-jobs depending on a predetermined limit of said sub-jobs, said sub- jobs being created in a sequential order such that each of said graphical objects is associated with one of said sub-jobs; code for rendering a predetermined image representing a blank image, to said page image; and code for rendering said associated outlines and fill for each of said graphical objects corresponding to each of said sub-jobs, over said predetermined image to form said page image, depending on said sequential order.

41. A program according to any one of claims 38 to 40, wherein said program is o stored in a memory medium of said apparatus and is executed by a processor of said apparatus.

42. A method of rendering a page image, said image comprising a plurality of graphical objects, said method being substantially as hereinbefore described with reference to any one of the embodiments as illustrated in Figs. 1 to 19.

43. An apparatus for rendering a page image, said image comprising a plurality of graphical objects, said method being substantially as hereinbefore described with reference to any one of the embodiments as illustrated in Figs. 1 to 19. I:\562665.doc 45

44. A program stored in an apparatus, said program being configured to render a page image, said image comprising a plurality of graphical objects, said program being substantially as hereinbefore described with reference to any one of the embodiments as illustrated in Figs. 1 to 19. DATED this Seventh Day of August 2001 Canon Kabushiki Kaisha Patent Attorneys for the Applicant SPRUSON FERGUSON I:\562665.doc