Method and apparatus for outline font character generation in dot matrix devices
CROSS REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation-in-part of U.S. patent application Ser. No. 07/771,382 (filed Sep. 30, 1991), entitled &#34;Method and Apparatus for Outline Font Character Generation in Dot Matrix Devices&#34;, assigned to the assignee of the present invention. 
    
    
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     This invention relates generally to methods and apparatus for converting electronically stored image data in outline form into a bitmap form which can be used to drive a dot matrix output device. More particularly, the present invention relates to an improved method and apparatus for converting input image data from a graphical/mathematical format to a display or print device format (i.e. a series of dots/pixels), wherein said method implements an outline font rendering process that provides scaling, scan-conversion, and shape filling of characters/graphics in spline outline formats. The method can be applied to a variety of font data input formats. 
     2. Description of the Prior Art 
     The outline font rendering process represents a large computational load and limits the performance of laser printer systems. More specifically, since the outline font rendering process must maintain typographic quality of an input font during font scaling and rotation as related to the limited resolution (typically 300 dots per inch) of a laser printer, a very slow printing rate/per page results. 
     A prior art outline font rendering process involves the following steps: 
     (1) Retrieving an outline font source data from a source of font character, wherein the character defines the outline of the source data with a set of curve and line control points. 
     (2) Transforming the source data in high precision to a set of control points (i.e., a transform image) related to a new coordinate system, wherein the same data is rotated and scaled accordingly. 
     (3) Correcting the transform image for misalignment by rounding its boundaries either up or down to the lowest quantized value of the new coordinate system. The output from this step is a corrected transformed image. Furthermore, the corrected transformed image is adjusted (according to the hints included with the curves and lines of the source data) to eliminate image distortions due to grid correction. 
     (4) Scan-converting the corrected transform image to a sequence of points occurring at periodic intervals along the outline of the image. This sequence of points is an image outline. 
     (5) Selectively filling the image outline with points to provide a solid representation of the image in bitmap form. 
     (6) Processing the resulting filled outline of the image by a raster operator, which produces a stream of data. 
     An outline font source data is made up of a set of control points of curves and lines which serve to define the outline of the source data. Referring now to FIG. 1 which illustrates the composition of the outline font source data of a small letter &#34;a&#34;, the figure is shown on a pixel grid blown up many times normal size in order to see the details of the original curves 10 and the short vector approximation to the curves 20. The arrows 30 show the order in which the curves are processed. 
     FIG. 2 shows an enlarged simple curve composed of straight lines and cubic Bezier curves. A straight line segment may be defined by two points: a start point 40 and an end point 42. A cubic Bezier curve is defined by four points: a start point 42, a first control point 44, a second control point 46, and an end point 48. The start and end points always lie on the curve. 
     FIG. 3 shows the same curve as FIG. 2 but rendered as quadratic B-Spline curves and straight lines. As before, straight lines are defined by a begin point 50 and an end point 52, both of which lie on the line. A quadratic B-Spline curve is defined by three control points but the control points come in two weights. Off-curve control points have a weight of &#34;one&#34;, while on-curve control points have a weight of &#34;two&#34;. The weight indicates how many times the point is used in developing curves of the contour. The first curve after the line segment is defined by the on-curve point at the end of the line segment 52 and the off-curve control point 54 so the three points that define the first curve are 52, 52, 54. The second curve is defined by the points 52, 54, 56, and the third curve is defined by 54, 56, 56. The process can be visualized as making a list of the control points with on-curve entries repeated, then taking groups of three entries to define a curve as follows: (Note that each vertical row of X&#39;s represents one defined curve.) 
     
         ______________________________________                                    
52    (on)      X                                                         
52    (on)      X     X                                                   
54    (off)     X     X      X                                            
56    (on)            X      X   X                                        
56    (on)                   X   X      X                                 
58    (off)                      X      X   X                             
59    (on)                              X   X                             
59    (on)                                  X                             
______________________________________                                    
 
    
     One problem in prior art devices is the transfer of redundant control point data. As discussed earlier, an outline font is made up of a set of curves or lines wherein each curve or line is made up of control points. When a curve of the outline font is processed all the control points associated with that curve must be transferred to the processing device. In many cases a control point is applicable to two curves, thus redundant data transfer occurs. 
     Scan-conversion is the process of selecting the pattern of device pixel dots which match the mathematical representation of the image outline to be displayed. FIG. 4 demonstrates one method of defining a set of transition points based on a pixel centered scan line 60. A transition is defined as a change of state along the scan line. That is, when a scan line crosses the outline of the character the &#34;insidedness&#34; of a point on the scan line changes going from outside to inside or inside to outside. Thus a transition is created each time one of the short vectors crosses the vertical centerline of a pixel for horizontal scanning. 
     The final placement of the transition is a function of first the pixel level rules for placement (e.g., transition detection with offset) and secondarily the character level rules (e.g., rules dealing with multiple transitions in a single pixel and handling image enhancement). FIG. 4 illustrates an example of a pixel level rule of transition detection and placement, the so-called 50-50 rule. If the point of intercept 62 with the horizontal scan line 60 placed at the vertical middle of the pixel occurs to the left of the horizontal center then the transition 64 will be assigned to the pixel in which the crossing took place. If the point of intercept 66 crosses on or to the right of the pixel center the transition 68 will be assigned to the pixel to the right of that which contains the intercept. 
     Most of the prior art devices and methods adapt the Bresenham algorithm for the scan-conversion process. Bresenham algorithms are described in the articles: (1) &#34;Algorithm for Computer Control of a Digital Plotter,&#34; IBM System Journal, Vol.4, No.1, 1965, by J. E. Bresenham, (2) &#34;A Linear Algorithm for Incremental Digital Display of Circular Arcs,&#34; Communication of the ACM, February, 1977, p.100-106, by J. E. Bresenham. 
     A problem with the prior art methods of scan conversion is that an independent and unique scan conversion method must be used for the different formats chosen by different typographic designers to store their type designs. That is, a different scan converter method must be used for vectors, arcs, Beziers, and B-spline. It is much more desirable for a commercial product to use one general set of scan-conversion and filling methods that can handle the various available font standards, rather than to use several independent methods for different formats. 
     Filling is the process of turning on device pixel dots which fall within the interior area bounded by the outline pixel dots generated from the scan-conversion process. There are two major filling algorithms found in the prior art: Even-Odd parity fill and Non-Zero Winding fill. FIG. 5 illustrates the even-odd parity fill algorithm along with the 50-50 transition detection rules. 
     Starting at the far left a value of &#34;0&#34; (outside or white) is assumed and maintained until the first transition 90 is encountered. At this point a value of &#34;1&#34; (inside or black) is assigned and maintained until the next transition 74 is encountered. The run of &#34;1&#34;s between &#34;0&#34;s is a horizontal span or fill for the character, in this case running from the first transition 70 to one before the second transition 74. The Even-Odd parity fill algorithm assumes that the character being processed contains no overlapping contours which were supposed to receive solid fill. 
     An alternate filling algorithm is &#34;Non-Zero Winding&#34;. This method assigns a value to each transition based on the sign of the Y component of the segment which created it. That is, a &#34;+1&#34; is assigned if the segment is horizontal or rises going from the segment&#39;s starting point to its endpoint, a &#34;-1&#34; is assigned if the segment is going down. If no transition occurs at a point it is considered &#34;0&#34;. To create the filled character the line is scanned from left to right starting with a value of zero and a sum is kept of the assigned transition values. A &#34;1&#34; (inside or black) is assigned to each point on the scan line where the sum is not zero. Thus, returning to FIG. 4, the first transition 68 would be assigned -1 because its segment is going down along the path being traced. The second transition 64 is assigned a +1 because its segment is going up. When the filling process is applied, returning to FIG. 5, the sum starts at &#34;0&#34; so the fill is left at zero until the first transition. The first transition has a value of -1, thus the sum is -1 (non zero) and the fill is set to &#34;1&#34;. The next transition is assigned +1 so the sum is &#34;0&#34; and the fill is set to &#34;0&#34;. For this case the result is identical to the result of the Even-Odd filling. 
     Referring now to FIG. 6 which illustrates a shortcoming of the Even-Odd parity fill algorithm, the figure depicts two overlapping contours, a horizontal rectangle 76, and a vertical rectangle 78 crossed to form a &#34;+&#34; character. When the character is filled with the Even-Odd parity fill algorithm, it is left with a hole in the center of the character. FIG. 7 depicts the same character filled using the Non-Zero Winding fill algorithm. The direction of tracing both the horizontal 90 and the vertical 91 contour is marked by arrows 92. A scan line 93 passing through the area of interest encounters a first transition 94 assigned with a -1, the second transition 95 is also assigned a -1, the third transition 96 is assigned +1, and the fourth 97 is assigned +1. The sum at the first transition is -1, at the second is -2, at the third is -1 and at the fourth is 0, thus between the first and fourth transition positions the fill is &#34;1&#34; continuously. 
     Hawes (U.S. Pat. No. 4,745,575) discloses a technique to accomplish area filling using hardware. A microprocessor performs the Bresenham algorithm of scan-conversion. Polysegments generated by the scan-conversion microprocessor are then fed to a hardware filling module. Hawes uses a single auxiliary memory to store the outline of a polygon area, and the Filling Starting Point and Filling Ending Point information for all the horizontal filling spans involved in the scan-converted polygons. Since the design is based on the integer Bresenham algorithm, it suffers a quality problem when it is applied to render outline fonts. 
     A scientific paper entitled &#34;Vertical Scan-Conversion for Filing Purposes&#34; by R. D. Hersch (Proceeding Computer Graphics International 88, Geneva, Springer Verlag, 1988), reports on studies of scan-conversion methods and describes a method for solving the incompatibility issue of scan-conversion and filling approaches. Splines are subdivided into variable lengths of polysegments which can have non-integer vertices. From intersections between the polysegments and scan lines, the algorithm determines two transition pixels for each horizontal span as the beginning and ending indicators. Each transition pixel indicates a color change, from black to white, or vice versa. Between the two transition pixels are interior pixels which are filled by applying a &#34;parity scan line fill method.&#34; In order to calculate the intersection and locate the transition pixels, a time-consuming geometrical computation is performed. The higher the resolution, the more calculations are involved. Since the method uses the Even-Odd parity filling algorithm, the problem dealing with overlapping contours (discussed earlier) OCCURS. 
     Lien (U.S. Pat. No. 4,855,935) discloses a technique to scan-convert curves and vectors by the hardware implementation of Adaptive Forward Difference (AFD) algorithm. Lien adapts the Forward Difference parameter increment so as to advance along the curve with a step size which is approximately equal to the distance between two adjacent pixels. This method is called &#34;Adaptive Forward Difference (AFD).&#34; Thus, in the Lien apparatus, curves and curved surfaces are rendered by AFD and vectors are rendered by Bresenham algorithm using many of the same circuit components utilized by AFD. Since the AFD algorithm does not require the high speed stack memory, it is more suitable for being implemented in the hardware apparatus. 
     Hassett (U.S. Pat. No. 4,937,761) discloses a technique for rendering outline fonts using hardware. In the Hassett device, a line or curve is scan-converted (&#34;discrete point conversion&#34; in Hassett&#39;s terminology) to polysegments. Then the polysegments are further transformed to the coordinate resolution of the target marking engine. Scaling up or down operations may be applied to the polysegments during the &#34;transforming&#34; process. Hassett also uses a dithering technique to smooth the polysegments which are further scan-converted during the &#34;transforming&#34; step. The final scan-converted and dithered polysegments are separated as a dithered image outline shape and a map of interior pixels to be filled, which are then combined for receipt by the raster operator. Two separated memories are required to store the outline points and filling starting point/filling ending points. The final bitmap image is provided by combining the outline image and the filled image resulting from parity filling all the starting points/ending points. Since the object outline is generated by the conventional scan-conversion algorithm (the Bresenham algorithm is used), the dithering technique is used instead of &#34;hinting&#34; to improve the bitmap image quality in Hassett&#39;s approach. 
     Another problem with the prior art method of hinting is that it is based at the character level. Character level hints require intensive processing which must be performed before any other image processing can be accomplished. Thus, hinting at the character level decreases the throughput of an outline font rendering system. 
     Still another problem with prior art devices is that the entire image is converted to bitmap format. This increases the memory requirements and decreases the throughput of these prior art font rendering systems. 
     SUMMARY OF THE PRESENT INVENTION 
     It is an object of the present invention to provide an apparatus and method to increase the throughput for an outline font rendering system. 
     Another object of the present invention is to provide an apparatus and method capable of accepting a multitude of character coding input forms to an outline font rendering system. 
     Yet another object of the present invention is to provide an apparatus and method to enhance the output image quality for an outline font rendering system. 
     Briefly, a preferred embodiment of the present invention includes a point transform engine for generating a scaled image and for retaining any control points applicable to subsequent processing, a parametric equation generator for computing a set of coefficients used in polysegment generation processing, an adaptive forward differencing engine for generating a set of uniform length vectors representing the image, a transition detection engine for determining the transition pixels by scanning the vectors both horizontally and vertically and determining whether a scanline is crossed by the vector, a transition processor for enhancing the image quality by altering the number and location of the previously determined transition pixel, an intermediate storage for accumulating the transition locations for the image until all curves for the image have been processed, and a bitmap converter for converting the transition information into bitmap format on a line-by-line basis. 
     An advantage of the present invention is to retain any control point data that is required to process subsequent curves or lines thereby reducing the amount of data transfer into point transform engine and thereby increasing the throughput of an outline font rendering system. 
     Another advantage of the present invention is to convert the stored transition data into the bitmap format on a line-by-line basis thereby increasing the throughput of an outline font rendering system. 
     Still another advantage of the present invention is to perform enhancement techniques at the pixel level hinting thereby increasing the throughput and the output quality of an outline font rendering system. 
     Yet another advantage of the present invention is to generate polysegments for characters coded in a plurality of distinct coding formats thereby increasing the throughput of an outline font rendering system. 
     Still another advantage of the present invention is to perform enhancement techniques for both vertical and horizontal scan detection thereby increasing the output quality of an outline font rendering system. 
     These and other objects and advantages of the present invention will no doubt become apparent to those skilled in the art after having read the following detailed description of the preferred embodiment illustrated in the several figures of the drawing. 
    
    
     IN THE DRAWING 
     FIG. 1 depicts a prior art rendering of a character into straight and curve segments; 
     FIG. 2 depicts a prior art representation of a Bezier contour; 
     FIG. 3 illustrates a prior art representation of a Quadratic B-Spline contour; 
     FIG. 4 shows a prior art method for detection of transition pixels; 
     FIG. 5 illustrates a prior art method of the Even-Odd parity fill algorithm; 
     FIG. 6 illustrates the shortcomings in the prior art Even-Odd parity fill algorithm; 
     FIG. 7 shows a prior art Non-Zero Winding fill algorithm; 
     FIG. 8 is a block diagram illustrating the principal functional components of a preferred embodiment of the present invention; 
     FIG. 9 depicts the characteristic points required for utilizing the inheritance logic of the present invention; 
     FIG. 10 is a block diagram illustrating the principal functional components of the point transform engine; 
     FIG. 11 is a block diagram illustrating the principal functional components of the parametric equation generator; 
     FIG. 12 is a diagram depicting the deficiency in horizontal scan techniques; 
     FIG. 13 is a block diagram illustrating the principal functional components of the transition processor; 
     FIG. 14 is a block diagram illustrating the principal functional components of the tile test device; 
     FIGS. 15a and 15b are diagrams depicting a character rendered with and without stub suppression; 
     FIG. 16 is a block diagram illustrating the principal functional components of the stub test device; 
     FIG. 17 is a diagram illustrating the bias or displacement technique used when the character is filled using the Non-Zero winding algorithm; 
     FIG. 18 is a diagram depicting a particular displacement method (left bias); 
     FIGS. 19a and 19b are diagrams depicting a character rendered with and without dropout control; 
     FIG. 20 is a diagram showing an application of the immediate or toggle patch technique; 
     FIGS. 21a, 21b and 21c depict a character rendered without dropout control and with dropout control with a toggle patch or with a black patch; 
     FIGS. 22a and 22b depict a character rendered with and without Y alignment; 
     FIGS. 23a, 23b and 23c are logic flow diagrams depicting the operational sequence of the sequence controller device of the transition processor; 
     FIG. 24 is a block diagram illustrating the principal functional components of the bitmap converter; 
     FIG. 25 is a block diagram illustrating the principal functional components of the Even-Odd converter; and 
     FIG. 26 is a block diagram illustrating the principal functional components of the Non-Zero converter. 
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     A block diagram showing the basic functional components of a preferred embodiment of the present invention is illustrated at 100 in FIG. 8. The process starts with a control source 102 which operates on a character description to produce a control point stream for character rendering as well as selecting the options for character conversion. The character, as represented by the control point stream, is operated on by a point transform engine 104 to generate a transformed point stream, that is, an image that is sized, rotated and/or skewed to an appropriate scale. A parametric equation generator 106 converts the rotated image or scaled curve into a set of coefficient values used to initialize an adaptive forward differencing engine 108. The adaptive forward differencing engine 108 approximates the image by outputting a normalized polysegment data set (i.e., a set of short vectors). Each vector is constrained to be less than one pixel width in both X or Y direction to satisfy the conditions of a transition detection engine 110. The transition detection engine 110 operates on the normalized polysegment data set to determine whether a transition pixel exists when the vector is scanned horizontally or vertically. The engine 110 also detects a vertical and horizontal tracing direction, determines whether the vector passes through a pixel&#39;s center, and whether either the X or Y component of the vector is zero. The output of engine 110 is an initial transition pixel data set that includes the transition pixel&#39;s address, whether the address for writing the transition should be displaced to the right, and a set of flags indicating details of the transition pixel. 
     The transition processor 112 accesses the intermediate storage 114 at the address of the proposed transition received from the transition detection engine 110. If there is already a transition stored at that location, a means of selecting the proper transition is performed. When a decision has been reached, the final transition pixel data, including the address of the selected transition pixel, is output to intermediate storage 114 where character image information accumulates until all curves for the character have been processed. When all curves of a character have been processed, a character mapper 118 may direct a bitmap converter 116 to start reading the bitmap converter scan line. 
     The scanline bitmap information is passed by the character mapper 118 into a page buffer 120 where multiple characters are accumulated to be sent to a dot matrix device 122. 
     The functions in blocks 102 to 114 operate in parallel on curve data to produce the data for intermediate storage. When the pipeline has finished processing the last curve of the character, the bitmap conversion process starts as a second operation comprising blocks 114,116,118, and 120. This second operation is not concurrent with the pipelined processing of the curves. 
     The point transform engine 104 provides a linear transformation of each control vector represented as an [X,Y]  coordinate pair and provides control point inheritance as applicable. Control point inheritance logic eliminates redundant transfer of control point data on the part of the control source 102. This logic holds and/or computes data from the last curve pertinent to the next curve. For example, in a Bezier curve the only information to be carried to the next curve is the absolute end address which is used as the starting address of the next curve. Thus, for Bezier curves the intermediate relative control point values are summed to produce the beginning point of the next curve and the intermediate points are cleared in preparation for the next curve. 
     For B-Spline curves each new control point can produce a new subcurve after the initial control points have been written. The control source 102 takes care of interpreting on-curve points as two consecutive control points and for cubic B-spline curves treats line segment endpoints as three consecutive control points. 
     Referring now to FIG. 9, when processing a cubic curve, four control points are needed to define a curve, a Z0[X,Y] 98 (absolute begin point), a DZ1[X,Y] 99 (first relative control point), a DZ2[X,Y] 100 (second relative control point) and a DZ3[X,Y] 101 (final relative control point). After the first curve is written the inheritance logic calculates a Z0 for the next curve as follows: 
     
         Z0&#39;=Z0+DZ1+DZ2+DZ3 
    
     Similarly for a quadratic B-Spline where only three control points are needed, the inheritance logic performs as follows: 
     
         Z0&#39;=Z0+DZ1 
    
     
         DZ1&#39;=DZ2 
    
     
         DZ2&#39;=0 
    
     
         DZ3&#39;=0 
    
     In addition to these techniques the concept of triggered execution has been added to again decrease bandwidth requirements on the control source 102 bus. That is, instead of loading the control points and then initiating activity with a start curve command, the loading of a certain parameter for each curve type triggers the start of processing. The curve type is loaded before curves are processed and need not be reloaded for subsequent curves of the same type. The trigger point for the curve types is as follows: 
     
         ______________________________________                                    
Line or Vector:         DZ1[Y]                                            
Quadratic (Bezier or B-Spline)                                            
                        DZ2[Y]                                            
Cubic (Bezier or B-Spline)                                                
                        DZ3[Y]                                            
______________________________________                                    
 
    
     In the worst case, where the curve type changes on every curve, it requires no more bandpass than the approach with a &#34;Curve Start&#34; command for every curve. 
     Referring now to FIG. 10, in the point transform engine 104 instructions are received by an instruction register 128, scaling factors are received by a set of four scaling input registers 124, and a set of coordinate pairs of the control vector are received by a set of eight control point input registers 126. The four Scaling Registers are specified as ScA (Scale factor A), ScB, ScC, ScD as used in the transformation formula: 
     
         Px&#39;=ScA*Px+ScC*Py 
    
     
         Py&#39;=ScB*Px+ScD*Py 
    
     The eight Control Point input registers are specified as coordinate pairs: 
     [P0x,P0y] (the x and y component of point Z0), 
     [DP1x,DP1y] (the relative vector from P0 to P1), 
     [DP2x,DPy2] (the relative vector from P1 to P2), 
     [DP3x,DPy3] (the relative vector from P2 to P3). 
     There are three accumulator registers 136 specified as: 
     AccTemp; used as storage for intermediate data. 
     AccP3x; used to calculate the x coordinate of the curve endpoint 
     AccP3y; used to calculate the y coordinate of the curve endpoint. 
     The arithmetic operations performed in the transformation process are handled by a two input adder 134 and a multiplier 130. The multiplier 130 takes one scale factor and one control point coordinate selected by the sequencer and produces a scaled control point (or a signed product) which is fed into the adder 134. The second input to the Adder is one of 4 values from the accumulators 136 (i.e., one of the three accumulator registers or zero). The adder&#39;s 134 output goes to the accumulators 136, which are selectably loadable, and to a plurality of control point output registers 140 by way of an output multiplexer 138. The output multiplexer 138 selects either the sum from the adder 134 or an inheritance value as an interim transferred input to the selectably loadable control point output registers 140. The preferred implementation for the multiplier 130 is as a combinatorial logic design and for the adder 134 is as a carry-look-ahead design. 
     The eight control point output registers 140 are specified as: 
     P0&#39;=[P0x&#39;,P0y&#39;]; transformed P0, 
     DP1&#39;=[DP1x&#39;,DP1y&#39;]; transformed DP1, 
     DP2&#39;=[DP2x&#39;,DP2y&#39;]; transformed DP2, and 
     DP3&#39;=[DP3x&#39;,DP3y&#39;]; transformed DP3. 
     The instruction register 128 is read by a sequence controller 132 which also monitors the loading of the other input registers to determine how to process the incoming data. All processing in the point transform engine 104 is conducted under the direction of the sequence controller 132, which is a sequential state machine. 
     A pseudocode example of the transformation of a quadratic 24 Bezier curve, as the first curve of a contour, is as follows: 
     
         ______________________________________                                    
AccTemp gets ScA * P0x + 0                                                
P0x&#39; and AccP3x get ScC * P0y + AccTemp                                   
AccTemp gets ScB * P0x + 0                                                
P0y&#39; and AccP3y get ScD * P0y + AccTemp                                   
(thus P0&#39; is stored and AccP3 = P0&#39;)                                      
AccTemp gets ScA * DP1x + 0                                               
AccP3x gets ScA * DP1x + AccP3x                                           
DP1x&#39; gets ScC * DP1y + AccTemp                                           
AccP3x gets ScC * DP1y + AccP3x                                           
AccTemp gets ScB * DP1x + 0                                               
AccP3y gets ScB * DP1x + AccP3y                                           
DP1y&#39; gets ScD * DP1y + AccTemp                                           
AccP3y gets ScD * DP1y + AccP3y                                           
(Thus DP1&#39; is stored and AccP3 = P0 + DP1.)                               
AccTemp gets ScA * DP2x + 0                                               
AccP3x gets ScA * dP2x + AccP3x                                           
DP2x&#39; gets ScC * DP2y + AccTemp                                           
AccP3x gets ScC * DP2y + AccP3x                                           
AccTemp gets ScB * DP2x + 0                                               
AccP3y gets ScB * DP2x + AccP3y                                           
DP2y&#39; gets ScD * DP2y + AccTemp                                           
AccP3y gets ScD * DP2y + AccP3y                                           
______________________________________                                    
 
    
     (Thus DP2&#39; is stored and AccP3=P0+DP1+DP2=P2 the endpoint of the curve and beginning of the next curve.) 
     The command output register 142 is loaded by the sequence controller with curve type information on a per curve basis and an &#34;End of Character&#34; flag on a once per character or tile basis. 
     The parametric equation generator 106 processes the transformed control point information, along with curve type, into a set of initialization parameters for the adaptive forward differencing engine 108. The mathematical expressions for the coordinate of a curve segment are: 
     
         X=f.sub.1 (t)=a.sub.1 *t.sup.3 +b.sub.1 *t.sup.2 +c.sub.1 *t+d.sub.1 
    
     
         y=f.sub.2 (t)=a.sub.2 *t.sup.3 +b.sub.2 *t.sup.2 +c.sub.2 *t+d.sub.2 
    
     where t ranges from 0 to 1 to produce a curve segment. The outputs from the parametric equation generator engine 106 are the starting point of the curve (D0) and the first (D1), second (D2), and third (D3) order difference equations of the curve at the starting point assuming a unit step. These outputs are calculated from the equations: 
     D0=d 
     D1=a+b+c 
     D2=6a+2b 
     D3=6a 
     The terms a, b, c, and d are calculated differently for each curve type as follows: 
     Cubic Bezier: 
     a=dP1-2*dP2+dP3 
     b=3* dP2-3*dP1 
     c=3*dP1 
     d=P0 
     Quadratic Bezier: 
     a=0 
     b=dP2-dP1 
     c=2*dP1 
     d=P0 
     Cubic B-Spline: 
     a=dP1-2*dP2+dP3 
     b=3*dP2-3*dP1 
     c=3*dP1+3*dP1 
     d=6*P0+5*dP1+dP2 
     Quadratic B-Spline: 
     a=0 
     b=dP2-dP1 
     c=2*dP1 
     d=2*P0+dP1 
     Vector or Line: 
     a=0 
     b=0 
     c=dP1 
     d=P0 
     The equations are evaluated in two passes through the data processing portion of this unit. Referring now to FIG. 11, the transformed point stream, or transformed control points, are input to an input register 152 via an input multiplexer 150. Multiplication by integers is handled by a shifter 154 and an adder 160 with a temporary register 158 used as an accumulator. The shifter 154 is a combinatorial left shift function, implemented as a multiplexer, capable of shifting 0, 1, or 2  positions providing the equivalent function of multiply by 1, 2, or 4. The adder 160 is a signed 2 input adder/subtracter. 
     In the first pass, the transferred control points are processed to calculate a plurality of parametric coefficients a, b, c, and d, for both X and Y coordinates. The parametric coefficients are interim values that are stored back into the input registers 152. In the second pass, the parametric coefficients are processed into the four difference equation parameters for both X and Y, and stored, as a difference equation parameter, into the eight output registers 162. These registers are referenced as follows: 
     D0[x,y]: 0th order difference for x and y equations 
     D1[x,y]: 1st order difference for x and y equations 
     D2[x,y]: 2nd order difference for x and y equations 
     D3[x,y]: 3rd order difference for x and y equations 
     The equation generator sequence control 164 controls the order of load commands for the registers and controls the function of the multiplexers and shifter. 
     The adaptive forward differencing engine 108 uses one of a number of well-known forward differencing techniques such as, for example, that technique disclosed in Sun Microsystems (U.S. Pat. No. 4,855,935) &#34;Method and Apparatus for Rendering Vectors Using Bresenham Parameters&#34;. 
     The transition detection engine 110 is described in detail in co-pending U.S. patent application of Jim C. K. Lo and James C. Y. Lung entitled &#34;Fast Vertical Scan-Conversion and Filling Method and Apparatus for Outline Font Character Generation in Dot Matrix Devices&#34; Ser. No. 07/730,181 filed Jul. 12, 1991, and assigned to the assignee of the present application, the disclosure of such application being expressly incorporated herein by reference. A feature of the transition detection engine 110 that is particularly relevant to the present invention is the vertical or Y scan capability. 
     A thin horizontally oriented feature can be overlooked by horizontal scanning if the feature crosses no pixel Y centerline. For example, referring to FIG. 12 which depicts a very small minus sign (&#34;-&#34;) character 168. During a horizontal scan the entire character is missed because no portion of the character crosses a pixel Y centerline. However, if the character had been scanned in the vertical or &#34;Y&#34; direction transitions would have been detected at six points 170 through 180. These transitions are not added to an X transition map because they can not preserve horizontal parity and could prove redundant. A separate Y transition map records these vertical or Y transitions 170-180. The transition processor 112, described below, processes these Y transition points. 
     The transition processor 112 is depicted in FIG. 13. The processor 112 is made up of a set of input registers 182, a tile test device 184, a stub test device 186, a sequence controller 188, a X coordinate adder 190 and a Y coordinate adder 192. The registers 182 receives an initial transition pixel data, including a set of coordinates of a current transition pixel and other information, via an input bus 194. The X coordinate of the current transition pixel is transferred to the stub test device 186 and the X coordinate adder 190 via an X coordinate bus 196. The Y coordinate of the current transition pixel is transferred to the stub test device 186, the tile test device 184, the sequence controller 188, and the Y coordinate adder 190 via a Y coordinate bus 198. The tile test device 184 operates on the Y coordinate of the current transition pixel to generate a TileOk signal 200. The stub test device 186 operates on the X and Y coordinates of the current transition pixel to generate a Stubflag signal 202. The sequence controller 188 receives as input the Stubflag signal 202, the TileOk signal 200, a set of current transition data 204, a set of stored transition data 206, and a set of process parameters 207. The sequence controller 188 operates on these various inputs to generate an X coordinate offset 208 and a Y coordinate offset 210. The X offset 208 is added to the X coordinate of the current transition pixel by the X coordinate adder 190. In similar fashion, the Y offset 210 is added to the Y coordinate of the current transition pixel by the Y coordinate adder 192. The X and Y adders output the newly calculated X and Y coordinate values of the transition pixel to the intermediate storage 114. 
     The stub test device 184 determines whether the current transition applies to the current process. In some instances, the character being processed is too large to be stored in the intermediate storage. When this happens the character must be partitioned into manageable portions. Referring now to FIG. 14, the tile test device consists of an upper limit comparator unit 212, a tile upper limit register 214, a lower limit comparator unit 216, and a tile lower limit register 218. If the Y coordinate of the transition pixel is below the upper limit and above or equal to the lower limit, the TileOk signal 200 is sent to the sequence controller and the transition will be processed, otherwise it is discarded. Thus, an overly large character will be sliced into horizontal bands as defined by the contents of the limit registers 214,218 and each band is processed as if it were a separate character. 
     The stub test device 186 suppresses serifs on small characters when an extra pixel can detract from the character&#39;s appearance. FIG. 15A shows a capital &#34;A&#34; rendered without stub suppression. FIG. 15B shows the same character with two pixels, 219 and 220, removed through stub suppression. The stub test device 186, illustrated in FIG. 16, is comprised of a last X transition register 222, a last Y transition register 224, an X coordinate comparator 226, a Y coordinate comparator 228, and a multiplexer 230. A stub is defined when two consecutive X transitions or Y transitions occur at the same location. When this occurs, the old transition is turned off and no new transition is written. The figure shows that the coordinates for the current transition pixel are compared against the coordinates of the previous transition pixel. Thus, the X coordinates of the current and previous transition pixels are compared by the comparator 226 and the Y coordinates are compared in comparator 228. If a Y transition is being processed, then the multiplexer 230 selects the output from comparator 228 as the StubFlag signal 202. If an X transition is being processed, the output from comparator 226 is selected as the StubFlag signal 202. 
     The sequence controller 188 operates on a plurality of inputs to generate corrections or offsets to the current transition pixel address. The input 206 from intermediate storage 114 is variable in length from one to four bits depending on the particular processing operation conducted. One bit, designated &#34;E&#34;, is always used to indicate the existence of a transition from the horizontal scan (i.e. an Xmap existence bit). When doing non-zero winding processing one bit, designated &#34;D&#34;, is used to indicate segment direction. When dropout prevention is applied one bit, designated &#34;Y&#34;, is used to indicate the presence of a transition from a vertical scan (i.e. a Ymap existence bit). When allowing black patches one bit, designated &#34;P&#34;, is used to indicate the occurrence of a black patch (i.e. a patch bit). The input 207 from the control source 102 specifies a set of process parameters that govern the operation of the sequence controller 188. These process parameters instruct the controller 188 to perform dropout protection, select a particular displacement method, select a particular patching method, and detect collisions. The process parameters also designate, to the controller 188, the fill algorithm to be employed by the bitmap converter 116. 
     A collision occurs when multiple transitions are assigned to the same pixel in the same map (i.e. X or Y map). If the controller 188 is instructed to detect collisions then a particular biasing method will be employed. The displacement method used by the sequence controller 188 is specified by an input parameter. For the Even-Odd algorithm two alternatives are provided. The first alternative turns off the first transition point and accepts only the second transition point. The second alternative displaces the second transition to a location to the immediate left or right. Both alternatives preserve scan line parity, however the first alternative can cause small features to disappear while the second alternative preserves fine detail. When a collision occurs during the displacement the opposite direction is tried; if that also collides then the transition in the original location is cancelled. 
     For the Non-zero Winding algorithm scan count must be preserved. The displacement method used for this algorithm is as follows: 
     If the value (+1 or -1) of a current transition is opposite of that of a transition already stored at that location, then set the location to indicate no transition. 
     If the value is the same, displace the transition to the left or right; in case of a another collision of like value, displace to the opposite side. 
     If further collisions of like value occur, go to the next position on the opposite side alternating until an empty position or a transition of opposite value is found. 
     FIG. 17 illustrates the described displacement method. In the particular method illustrated, a left bias method is employed. The current or new transition 232, of value +1, is to be mapped at location 234. However, a transition pixel, of value +1, is already mapped at location 234. Thus, a collision takes place at location 234. Since this is a left bias displacement method, the transition 232 is displaced to location 236 which causes another collision. The transition 232 is again displaced to location 238, then to location 240, then to location 242, and finally to location 244. Since location 244 has a pixel of opposite value to the new transition 232, a &#34;no transition&#34; is written at location 244. 
     There are three bias options available: a left bias, a right bias, and an auto bias. The initial displacement of the transition is to the left in the left bias and to the right in the right bias. The auto bias option selects right or left bias on a transition by transition basis. If a segment has a diagonal positive slope then the left bias option will be used. If a segment, with a Y transition only, is horizontal and the transition has been offset to the right by the 50-50 transition rule then the left bias option will be used. For all other cases, the right bias option will be used. FIG. 18 illustrates an example of left bias collision handling. The figure depicts a small sloped rectangle 245 which fits within a single pixel 246. During a scan, a transition on the left side 248 and a transition on the right side 250 are produced. Using the 50-50 rule transition 248 is assigned 254 to a pixel 253. However, under the same 50-50 rule, transition 250 is also assigned 252 to the same pixel 253 thereby causing a collision. Left bias collision handling causes transition 248 to be displaced 256 to a pixel 258 to the left. 
     Horizontal scanning, as pointed out earlier, can overlook thin horizontal features. Consequently, vertical or Y scanning is performed on smaller characters to compensate for this deficiency in the horizontal or X scan. A separate Y map is kept for the recording of vertical or Y transitions, however no conversion to bitmap is done on these Y map transitions. A collision occurs in the Y map where Y transitions do not interfere with the X map but do add information. Consequently, a fine feature found by a Y scan, but missed by an X scan, will not be represented in the X map. At these collision points in the X map a patch can be placed to enhance the final output image of the character. This patch can take one of two forms, a transition pair patch to the X map, or a black patch to the final character. FIG. 19a illustrates a character without patching. FIG. 19b shows the same character with patching performed. The patches 259-264 occur at the junction of a descender and the main body of the letter which is removed because of horizontal scan collision displacement. 
     The first option, which can only be used with the Even-Odd fill algorithm, is to write an immediate or toggle patch at the corresponding collision location in the X map. A single pixel of opposite polarity in the X map will result at the point of collision in the Y map. In case of a collision between the patch and an existing transition in the X map, the existing transition is turned off. FIG. 20 shows the application of an immediate patch. An existing X map 267 is shown with two well separated transitions 266 and 268. An immediate patch is introduced at point &#34;P&#34; 272 and produces a transition 274 at the corresponding location 278 of the X map 270 and at a position 276 to its immediate right. The converted X map now features a white pixel, at location 278, in what had been a solid black span. 
     The second option (the only patching method available for Non-zero winding) is the black pixel patch. After a collision is handled in the Y map an entry is made into a patch map which is later written into the bitmap converted character. 
     FIG. 21a shows a capitol &#34;F&#34; with no dropout correction. FIG. 21b shows the same character, with dropout correction using toggle patches recovering five dropped pixels 280-284. FIG. 21C shows the same character with dropout correction using black pixel patches recovering six dropped pixels 280-285. 
     Another technique for enhancing the image output is Y alignment. This technique prohibits any attempted bias away from the baseline. FIG. 22a shows an Even-Odd filled &#34;K&#34; processed with autobias but without Y alignment. The residual artifacts 287-290 detract from the character&#39;s final appearance. FIG. 22b depicts the same character processed with Y alignment. The residual artifacts 287-290 have been moved toward the character baseline 291 and into alignment with the rest of the character. When the Y alignment option is set, the sign of the Y coordinate is checked. If the value of the sign as seen by the sequence controller is zero (ie, on or above the character baseline) the displacement for a Y transition is always down. If the sign is 1 (ie below the baseline) the displacement for a Y transition is always up. This overrides any other bias that may be set in the dropout prevention mode. 
     The operation of the sequence controller 188 (FIG. 13) is illustrated in FIG. 23a. Referring now to FIG. 23a, the process parameters 207 (FIG. 13) are read by the controller 188. The initial decision, at block 302, is to determine whether dropout protection is required. The second major decisions, at blocks 304 and 305, are to determine whether the Non-Zero Winding fill algorithm will be used to generate the bitmap. Since there are two major decisions, there are four major operational paths. 
     If there is no dropout protection and Non-Zero Winding is not to be performed (i.e. an Even-Odd fill method is to be used) then, as illustated in block 307, the existence bit (&#34;E&#34; bit) at the address location of the current transition pixel is set to a value opposite of the current value of the &#34;E&#34; bit. The controller 188 then awaits the occurrence of the next transition pixel. 
     If there is no dropout protection but Non-Zero Winding is to be performed then, as illustated in block 306, the existence of collisions in the X map is performed. If there are no collisions, then, as shown in block 315, the &#34;E&#34; bit at the address location of the current transition pixel is set to a value of &#34;1&#34; and the direction bit (&#34;D&#34; bit) is set to a new direction value; the controller 188 then awaits the occurrence of the next transition pixel. However, if there are collisions in the X map then the controller 188 generates NZ displacement data in accordance with the sequence labelled &#34;C&#34; and described below in the discussion of FIG. 23c. 
     If there is dropout protection and Non-Zero Winding is to be performed then the controller 188 generates NZ processing data in accordance with the sequence labelled &#34;B&#34; and described below in the discussion of FIG. 23c. 
     If there is dropout protection with the Even-Odd fill algorithm, then the controller 188 checks for the existence of a Y transition, as illustrated by block 303. If there are no Y transitions then, as illustrated in block 310, the controller 188 checks for X map collisions. If there are no X map collisions then, as illustrated in block 311, the existence bit (&#34;E&#34; bit) at the address location of the current transition pixel is set to a value of &#34;1&#34;; the controller 188 then awaits the occurrence of the next transition pixel. However, if there are collisions in the X map then the controller 188 generates even-odd horizontal displacement data in accordance with the sequence labelled &#34;A&#34; and described below in the discussion of FIG. 23b. 
     If there are Y transitions then, as illustrated in block 309, the controller 188 checks for Y map collisions. If there are no Y map collisions, then, as illustrated in block 313, the existence bit (&#34;E&#34; bit) at the address location of the current transition pixel is set to a value of &#34;1&#34;; the controller 188 then awaits the occurrence of the next transition pixel. However, if there are collisions in the Y map then the controller 188 generates even-odd second scan processing data in accordance with the sequence labelled &#34;F&#34; and described below in the discussion of FIG. 23b. 
     Referring now to FIG. 23b, if there is dropout protection used with the Even-Odd fill algorithm, and a Y transition exists, and a collision in the Y map is found, then the controller 188 generates even-odd second scan processing data in accordance with the sequence labelled &#34;F&#34;. The Even-Odd displacement method, indicated by bracket 312, was described earlier and is employed in the Y orientation. At the conclusion of the displacement method, the patching method is selected, as illustrated by block 314. If the black patch method 317 is selected then a patch map &#34;P&#34; bit is set at the address of the current transition pixel plus some calculated offset. If the immediate or toggle patch method 316 is used then the method illustrated in FIG. 20 is employed. However, if there is dropout protection used with the Even-Odd fill algorithm, but a Y transition does not exists yet a collision in the X map is found, then the Even-Odd displacement method, indicated by bracket 318 and described earlier, is employed but in the X direction. At the conclusion of methods 318, 317 or 316 the controller 188 awaits the occurrence of the next transition pixel. 
     Referring now to FIG. 23c, if there is dropout protection and Non-Zero Winding is to be performed then the controller 188 generates NZ processing data by checking for Y transitions (i.e. block 320). If there are no Y transitions, then, the X map is checked for the existence of any collision by block 321. If there is no X map collision, then, as illustrated by block 322, the &#34;E&#34; bit is set to &#34;1&#34;, and the direction bit (&#34;D&#34; bit) is set a new direction value; the controller 188 then awaits the occurrence of the next transition pixel. However, if there is a X map collision then the controller 188 generates NZ displacement data in accordance with the sequence labelled &#34;C&#34;  and described below. 
     If there is a Y transition, as indicated by block 320, then the controller 188 checks for a collision in the Y map (i.e. block 323). If there is no Y map collision, then, as illustrated by block 324, the &#34;E&#34; bit at the address of the current transition pixel is set to &#34;1&#34;; the controller 188 then awaits the occurrence of the next transition pixel. However, if there is a Y map collision then the controller 188 generates even-odd second scan processing data in accordance with the sequence labelled &#34;F&#34; and described above in the discussion of FIG. 23b. 
     If there is no drop-out protection and the selected fill algorithm is NZ Winding, and there is a collision in the X map, the controller 188 generates NZ displacement data in accordance with the sequence labelled &#34;C&#34;. This displacement method, indicated by bracket 308 has been previously discussed in association with FIG. 17. 
     The intermediate storage 114 is a RAM storage device with one entry stored per pixel. An entry, described previously, is four bits in length. 
     The present invention minimizes the bandpass bottleneck to the intermediate storage 114 by minimizing the amount of information transferred into and out of the storage 114. As transitions are processed their addresses are monitored to determine the minimum and maximum addresses in both X and Y directions. These four values represent a character bounding box. This box limits the area to be accessed to the area of the actual character image which may be considerably smaller than the workspace required to render the character. This technique also minimizes the area to be cleared in preparation for the next character. 
     The bitmap converter 116 converts the transition map to a bitmap, including all appropriate patches, on a line by line basis, providing the bit map data directly to the character mapper 118. Referring now to FIG. 24, which illustrates the bitmap converter 116 design. The converter 116 consists of an Even-Odd converter 330, a Non-Zero converter 332, an input multiplexer 334, a temporary register 336, a patching logic device 338, an output multiplexer 340, an output register 342, a line address register 344, a line bit counter 346, and a bitmap sequence controller 348. The line address register 344 and the line bit counter 346 operate on a line address data signal 350, and a bit offset and length data signal 352 respectively from the character mapper 118 to generate a character map address signal 354. The bitmap sequence controller 348 controls loading of a stored transition data word signal 356 into the Even-Odd 330 and Non-Zero 332 converters. The transition data word signal 356 consists of a series of consecutive data words along a particular scan line. Depending on the fill option selected either the Even-Odd converter 330 or the Non Zero converter 332 will operate on the transition data word signal 356 to generate an initial bitmap signal 358-360 (either an even-odd bitmap signal 358, or a non-zero winding bitmap signal 360). Depending on the fill option selected, the input multiplexer selects the appropriate initial bitmap signal 358-360 to output a selected bitmap signal 362 to the output multiplexer 340 and the temporary register 336. The temporary register 336 stores the selected or interim bitmap signal 362 (i.e. either signal 358 or signal 360) in preparation for patching. The patching logic device 338 operates on the transition data word signal 356 and the stored bitmap signal 368 to generate a logic &#34;OR&#34; or patched bitmap signal 364. The output multiplexer 340 selects between the selected bitmap signal 362, or the patched bitmap signal 364, to generate a bitmap signal 366. The output bitmap signal 366 is stored in the output register 342 in preparation for reading into the character mapper 118. 
     The Even-Odd Converter 330 is shown in more detail in FIG. 25. Referring now to FIG. 25 it can be seen that the converter 330 consists of a remainder register 370 and a plurality of exclusive-OR gates 372. The leftmost bit 374 of the transition data word signal 356 is XORed with the contents of the remainder register 370 to produce the leftmost bit 376 of the initial bitmap signal 358. Each successive bit of the transition map is XORed with the bitmap value of its preceding bit to the end of the word. The rightmost bitmap bit 378 is then stored into the remainder register 370 as the bit to the immediate left of the first bit of a next word (assuming multiple words are required to scan a line). When starting the conversion of a new line the remainder register 370 is reset to zero. 
     The Non-Zero Winding Converter 332 is detailed in figure 26. Referring now to FIG. 26, the converter 332 consists of a remainder register 380, and a plurality of NZ cell devices 382. In addition, the NZ cell device 382 is made up of an adder/subtracter device 388, an &#34;AND&#34; gate 384, and an NZ detect device 386. In Non-Zero Winding two bits per pixel are required to generate the initial bitmap signal 360. An existence bit signal 390 and a direction bit signal 392 code the three possible transition map entries for any pixel. The remainder register 380 contains the standing count of previous words in the current scan line. The remainder register 380 is a N-bit register with &#34;N&#34; chosen to reflect the maximum expected imbalance of transition directions along a scan line. A &#34;N&#34; value equal to four can handle most characters and a &#34;N&#34; value equal to six should handle practically all characters, however there is no theoretical limit. 
     The transition data word signal 356 is brought into the NZ cell device 382 which looks at a previous pixel output count signal 394 and at the existence bit signal 390 and the direction bit signal 392 to generate an output bit signal 396 at a value of &#34;1&#34; if a new scan count signal 398 is at a non zero value. The new scan count signal 398 is calculated by the following rules: 
     if a transition does not exist, then pass the previous pixel output count signal; 
     if a transition exists then, 
     if the direction value equals &#34;0&#34; then add one. 
     if the direction value equals &#34;1&#34; then subtract one. 
     Thus, in the preferred implementation, if the existence bit signal is set to &#34;1&#34; (i.e. a transition exists) then the &#34;AND&#34; gate 384 generates a &#34;1&#34; to an input 402 of the adder/subtractor device 388. If the direction bit signal 392 is set to &#34;1&#34; then the adder/subtractor device 388 subtracts the input 402 (i.e. &#34;1&#34;) from the previous pixel output count signal 394 and outputs this difference as the new scan count signal 398. If the direction bit signal 392 is set to &#34;0&#34; then the adder/subtractor device 388 adds the input 402 (i.e. &#34;1&#34;) to the previous pixel output count signal 394 and outputs this sum as the new scan count signal 398. However, if the existence bit signal is set to &#34;0&#34; (i.e. a transition does not exist) then the &#34;AND&#34; gate 384 generates a &#34;0&#34; to the input 402 of the adder/subtractor device 388 and outputs the previous pixel output count signal 394 as the new scan count signal 398. If the product of the word width and N is large, a carryless adder is recommended to maintain speed. 
     The scan count signal 400 from the rightmost pixel of the transition data word signal 356 is stored into the remainder register 380. At the start of a line the remainder register 380 is reset to zero. 
     The character mapper 118 takes the output bitmap signal 366 from the bitmap converter 116 and writes it line by line into the page buffer 120. In the preferred implementation, with the rasterization as a slave process, the character mapper 118 requests each line of the output bitmap signal 366 from the bitmap converter 116. 
     Although a preferred embodiment of the present invention has been disclosed above, it will be appreciated that numerous alterations and modifications thereof will no doubt become apparent to those skilled in the art after having read the above disclosures. It is therefore intended that the following claims be interpreted as covering all such alterations and modifications as fall within the true spirit and scope of the invention.