JP3883078B2 - Graphic image generation method - Google Patents

Description

  The present invention relates to a printer driver and a communication method between a computer and a printer in a computer graphics system. More particularly, the present invention relates to a printer driver that implements a graphic function using a set of graphic primitives.

  Drawing (rendering) a graphical image is relatively complex, whether it is on a computer display or on a printed page. And because of its complexity, several different graphical languages have been developed. Some of these languages are basically suitable for generating hard copies, such as, for example, Printer Control Language. The “page description” language is suitable for displaying an image on a computer screen and printing an image on a print medium. For example, in a Macintosh computer, a graphics library known as “QuickDraw” is incorporated as a part of the Macintosh operating system, and is used for image formation on a screen or other than a screen. Similarly, in a PC compatible computer, the Windows (registered trademark) operating system is provided with a drawing routine in the form of a graphics device interface library. This graphics device interface library is for imaging all complex graphics functions on and off the screen. Here, the present invention will be described with reference to QuickDraw. However, it should be understood that the present invention is applicable to a wide variety of other graphical languages.

  As shown in FIG. 1, QuickDraw converts graphics commands from a high-level application program for presentation on a video screen and printing on a print medium. QuickDraw provides a graphics library that is built into every Macintosh computer. Note that QuickDraw is described more fully in Inside Macintosh, Vol. 1, published by Apple Computer, which is incorporated herein by reference. QuickDraw is used to draw most of the contents of a computer screen and also to communicate with a computer printer. Therefore, the QuickDraw routine stored in the computer's read-only memory (ROM) constitutes the core for creating a printer driver with control functions that depend on the particular printer. The printer driver causes the printer to print a desired image on the page in response to a command from the application program.

  QuickDraw defines several obvious mathematical structures. These mathematical structures are widely used in processing, in functions, and in data types. The most basic QuickDraw type is a point, which consists of two integer values that specify the horizontal and vertical position on the seating surface. Other types include lines, rectangles, ellipses, arcs, round rectangles, polygons, and regions. Many drawing operations consist of filling or framing these objects with patterns. QuickDraw also supports rendering of text in various sizes and styles in multiple fonts. QuickDraw performs drawing by changing the bit image in the memory area. Here, the memory area is a frame buffer in the case of a display screen, and a print buffer in the case of print output.

  QuickDraw can define a plurality of separated drawing areas called GrafPort. Each GrafPort has its own complete drawing environment, which defines how and where the graphic functions are performed. Many GrafPorts can be opened at once. Each GrafPort has its own coordinate system, drawing pattern, background pattern, pen size, arrangement position, character font, style, and the like. GrafPort is the basis for the Macintosh overlapping window user interface. One GrafPort can be designed as a printer GrafPort to render a page for printing.

  Each GrafPort has a rectangle called portRect, which defines the area of use by that GrafPort. Each GrafPort has a unique clipping region. The clipping region is used to further restrict drawing for all subsets of GrafPort's portRect. Each GrafPort has a drawing pen that is used to draw lines, graphics, and text. The pen has four feature values. That is, the position, size, drawing mode, and drawing pattern. Pen mode and pen pattern determine how the bits under the pen are affected when the pen is moved to draw a line or shape. Each GrafPort has its own text font, style, mode and size for drawing within that GrafPort.

  There are five different drawing operations for drawing different image figures. That is, frame, paint, erase, invert, and fill. Each of these drawing operations can be applied to rectangles, regions, long arcs, round rectangles, and polygons. In addition, QuickDraw provides routines for drawing text and performing bit copy operations.

  For each graphic that QuickDraw can generate, there is a separate process that performs basic graphic operations to generate that graphic. That is, frame, paint, erase, reverse, fill. Each of these processing steps calls up the QuickDraw low-level routines in order to actually perform the drawing of the graphic. For example, the ellipse frame, ellipse paint, ellipse erase, ellipse flip, and ellipse fill operations in QuickDraw actually call a single low-level routine in QuickDraw that performs these operations on the ellipse. There are also low-level processes for performing text and line drawing and bit copy operations. Low level routines, also called bottleneck procedures, may be considered graphic primitives. The main QuickDraw bottleneck procedures are StdText, StdLine, StdBits, StdRect, StdOval, StdPoly and StdRgn.

  To image a page, the QuickDraw printer driver first operates in the capture mode of operation and then operates in the playback mode of operation. Typically, during capture, commands for changing the settings of GrafPort and drawing various graphics are received. Information reflecting these changes is saved into the stream, for example to a disk file. When the ClosePage command is received, the printer driver waits for the application program. Then, the printer driver recalls the graphic describing the page and the change of the GrafPort (play back), manipulates the bits in the print buffer, and draws the image of the page. Due to the memory-dependent nature of graphic information, pages are typically imaged as a series of bands.

  Most QuickDraw printer drivers use a method called “DrawPicture” for printing. This method requires that each and every GrafPort change be recorded and recalled for each band. As a result, the number of disk accesses required for a typical print job and the amount of disk storage increase. The printing time is longer due to the presence of the disc.

  One solution is that instead of recording each and every change to the printer GrafPort in the order in which it occurred, each time a command to draw a figure is received (the state of the GrafPort is written last) After that, every time there is a change), a snapshot of the state of GrafPort can be recorded in the stream. Thus, graphics are stored in the stream with respect to the status of GrafPort. In addition, information indicating the boundary of the rectangular area of the graphic is stored together with the graphic. When the printer driver renders an image band, it can send the band's bounding rectangle to the stream manager, which requires the playback of only the shape that the shape's bounding rectangle is crossed by the imaging band.

  In this improved configuration, the printer driver then essentially stores the compressed picture of the GrafPort in the state object as each graphic is rendered by the application. When a figure is drawn in the imaging band, only the specific state required for drawing is required to be read back, and no order of change for GrafPort is required.

  However, such an arrangement uses a relatively large amount of data to save the state. In particular, storing the pen pattern and fill pattern in each state results in the storage and retrieval of a large amount of data.

  Therefore, what is needed is to provide a method for generating a graphic image using less disk access and disk space without replaying the original drawing environment specified by the drawing application and reducing its capability. is there.

[Summary of Invention]
A graphics image generation method according to an aspect of the present invention includes
A method for generating a graphic image using a set of graphics primitives in a computer having a memory system, comprising:
Each of the graphics primitives is executed according to the current state of the graphics environment when a command to activate the graphics primitive is received, the current state of the graphics environment including a plurality of state components, depending on the image source. It will change from time to time,
The computer detecting that at least one of the plurality of state components has changed between receipt of a previous command including graphics primitives and reception of a current command including graphics primitives;
Each time the computer detects that at least one of the plurality of state components has changed, saving only the changed state component to the memory system; and
A state of the graphics environment for the graphics primitive corresponding to the current command, wherein the computer includes, for each of the plurality of state components, a reference set that includes a reference to the contents of the most recently saved state component. And saving to the memory system as
Each reference set includes a reference that points to the contents of only one state component, and the contents of at least some state components are pointed to from the plurality of reference sets.

  The invention will be better understood from the following description in conjunction with the accompanying drawings.

  The present invention relates to the steps required in capture and playback when following the previous method, and in capture and playback (translation) according to the preferred embodiment of the present invention, for the specific example. It will be best understood by the method of comparing in detail with the steps performed.

  First, as shown in FIG. 2, the printer driver basically includes a capture module (ie, a captor), a playback module (ie, a translator), and a stream manager (ie, streamer object). The capter records a drawing command issued by the application program and a change in the drawing environment (GrafPort). The translator plays back the information recorded by the captor, executes graphics primitives to image the band of picture information, and sends the band to the printer hardware. The streamer object functions as a communication interface with the memory. The memory may be, for example, a cache memory, a disk memory, or a combination thereof.

  To give a very simplified example, assume that an application program instructs the printer driver to print the image shown in FIG. The image of FIG. 3 includes first and second rectangles having a pen pattern and a fill pattern.

  According to previous methods, GrafPort is compared to the previously saved copy to determine if there has been any change in GrafPort. When a change is found, every important field of GrafPort is copied to the state record. The state is then sent to the streamer object and saved to the stream. Therefore, the following steps occur when performing a capture.

1. The application sets initial GrafPort settings.
2. The application draws the first rectangular frame.
3. The captor compares the current GrafPort with the previous saved state.
4). A change in the pen pattern is discovered.
5). Each part of GrafPort is copied to the memory, color matching is performed (in the case of color QuickDraw), and saved to the stream as a single state.
6). For the new state just saved, the first rectangle is saved to the stream.
7). The application changes the fill pattern.
8). The application draws the second rectangle.
9. The captor compares the current GrafPort with the previously saved state .
10. Changes (changes in fill pattern) cause each part of the GrafPort to be copied, color matched, and saved in the stream.

Subsequently, the following steps occur during the execution of the translation.
11. The translator causes the first rectangle to be read.
12 The translator compares the state reference saved with the rectangle with the previous state and finds the difference.
13. The new state referenced for the rectangle is loaded.
14 Each field in the new state is compared to GrafPort and any different fields are updated in GrafPort.
15. The translator executes the appropriate graphics primitive to draw the rectangular frame.
16. The translator causes the second rectangle to be read.
17. A new state is read from the stream by comparing the states.
18. Each field in the new state is compared to the GrafPort and any different fields are updated in the GrafPort.
19. The translator executes the appropriate graphics primitive to draw the second rectangle.

  Since every important field of the GrafPort is saved to the state and the state is saved to the stream each time a change is discovered, there is a non-negligible overhead for writing to and reading from the memory. This is more noticeable if the memory is a disk memory.

In contrast, according to the present method, the state of each pattern or clip region is not satisfied, but the reference for each of these contents is stored in the state. This reference allows each component of the state to be saved separately and also allows the state to be accurately reproduced when drawing. Furthermore, the reference can save useful time during state comparison. Whereas the previous driver requested a state for the comparison of the GrafPort at the time of translation, in this method, each reference in the current state is changed to the previous state in order to see which field (which component) has changed. Compared to each of the references. Comparing references that can be stored in 4 bytes is much faster than comparing large patterns and regions.

According to the method, the following steps occur during capture execution.
1. The application sets an initial GrafPort set.
2. The application draws the first rectangular frame.
3. The captor compares the current GrafPort with the last saved state component.
4). A change in the pen pattern is discovered.
5). A new pen pattern is written to the stream.
6). The current state is updated and written out for the new pen pattern.
7). A rectangle is saved in the stream for the new state.
8). The application changes the fill pattern.
9. The application draws the second rectangle.
10. The captor compares the current GrafPort with the last saved state .
11. A new fill pattern is discovered.
12 A new fill pattern is written to the stream.
13. The current state is updated and written out in relation to the new fill pattern.
14 A second rectangular shape is saved in the stream in association with the new state.

It should be noted that significant differences between steps 5 and 6 and the prior art in steps 12 and 13 during capture execution are noted. When the pen pattern or fill pattern changes, the complete state is no longer written out. Instead, the new pattern itself is written out and the reference to it is saved in the state. What is written out as a new state is therefore a collection of references, not a pattern itself.

Subsequently, according to the method, the following steps occur during the execution of the translation.
15. The translator reads the first rectangle.
16. The translator compares the state reference stored with the rectangle and the previous state and finds that the pen pattern reference has changed.
17. A new pen pattern is read and updated in GrafPort.
18. The translator draws a rectangular frame.
19. The translator reads the second rectangle.
20. The translator discovers that the state reference has changed and loads it into a new state. Then, the new state reference is compared with the previous state reference to discover that the fill pattern reference has changed.
21. A new fill pattern is read and updated in GrafPort.
22. The translator draws the second rectangle.

It should be noted that in translation, steps 16 and 17 and steps 20 and 21 have significant differences from the prior art . Instead of comparing every field in the new state with GrafPort, the translator recognizes the new reference in the state indicating that the GrafPort field should be updated and simply updates that field.

  FIG. 4 is a diagram showing a new format of state information. For each item of the clipping region, visible region, pen pattern, fill pattern, and background pattern, each item is saved separately in the stream together with the reference stored as the current state. However, not all items. The information saved in the stream as a state for a given drawing operation includes information of a total of 40 bytes. In the previous method where the aforementioned items are saved in the state itself, as shown in FIG. 5, the information saved in the stream as a state will contain approximately 200 bytes of information in total. Depending on the number and frequency of GrafPort changes, the method can reduce the memory access overhead by half or less. In extreme cases where the clipping region and the visible region are large (maximum 32,000 bytes), the degree of improvement is extremely large.

  FIG. 6 shows a result file stored and read back by the streamer object. For example, a graphic record such as “Rect” indicating a rectangle is stored in the state record together with a pointer. The state record sequentially specifies items such as pen patterns. The same item can be specified from other state records.

  It will be apparent that the invention may be practiced by those skilled in the art in other specific forms without departing from the spirit or essence of the invention. The embodiments disclosed herein are therefore to be considered in all respects illustrative and not restrictive. The scope of the invention is indicated by the appended claims and not by the foregoing embodiments. All modifications that can be implemented within the scope of the present invention and equivalents are intended to be embraced by the present invention.

2 is a block diagram illustrating a printer driver in association with other elements of a computer graphics system. FIG. FIG. 2 is a block diagram illustrating a more detailed configuration of a basic module of the printer driver in FIG. 1. FIG. 4 is a diagram illustrating an example of an image drawn by a printer driver. FIG. 6 is a diagram illustrating a new state format according to the present invention. It is a figure which shows an old type state format. FIG. 5 is a schematic diagram of a file format using the state expression shown in FIG. 4.

Claims (1)

A method for generating a graphic image using a set of graphics primitives in a computer having a memory system, comprising:
Each of the graphics primitives is executed according to the current state of the graphics environment when a command to activate the graphics primitive is received, the current state of the graphics environment including a plurality of state components , depending on the image source. It will change from time to time,
It said computer comprises the steps of detecting a from the time of reception of the previous command containing the graphics primitives until the reception of the current command including graphics primitives, that at least one of said plurality of state component is changed,
Each time the computer detects that at least one of the plurality of state components has changed , saving only the changed state component to the memory system; and
A state of the graphics environment for the graphics primitive corresponding to the current command, wherein the computer includes, for each of the plurality of state components , a reference set that includes a reference to the contents of the most recently saved state component. And saving to the memory system as
Each reference set includes the contents of only one state component fingers to reference, the contents of at least some of the state component, graphic images generated and wherein the pointed from a plurality of reference sets.

Images