JPH06161421A - Character generating device - Google Patents

Abstract

PURPOSE:To obtain the best processing speed of a system and to improve character quality by providing a raster block which reads dot data in, paints out the inside of the outline of a character, and stored the resulting data in a dot memory again. CONSTITUTION:This character generating device is equipped with a CPU interface 2, a front input FIFO 3 which temporarily stores outline font data from a font memory, and a vector block 4 which reads the outline font data our of font input FIFO 3 and converts the coordinate data. Further, the device is equipped with a FIFO 5 which temporarily stores the converted coordinate data, a raster block 6 which reads the coordinate data in and generates a line of dots between the coordinate data, the dot memory 7 which stores the dot data, and a raster block 4 which reads the dot data in, paints out the inside of the outline of the character, and stores the resulting data in the dot memory 7 again. Therefore, the best processing speed for the system is obtained and the device scale is reducible.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a character / graphics generator in the field of computer graphics, and more particularly to a character / graphics generator for converting outline data of a character / graphic represented in a vector format into raster format data.

[0002]

2. Description of the Related Art As a method of outputting characters of a plurality of sizes and characters such as rotation and italics, there is an apparatus for converting outline font data composed of character outline information into dot font data. The outline font data is composed of data in which the points on the outline of the character are represented by coordinate values, flag data indicating the attributes of the data, and the like. Use this outline font data as a character font
The coordinate conversion operation called affine transformation is performed according to the specified output size in the OM or the external storage device, and in order to output the curve of the character beautifully, the coordinate conversion operation is performed on the coordinate data on the curve by curve interpolation. Output. Further, there is a character generator that generates a line with dots between coordinate-converted coordinate data, fills the outline of the generated character, converts it into a dot font, and outputs it.

FIG. 16 shows the Japanese Patent Application No. 2 filed by the applicant earlier.
No. 19052, “Character generator”, it is an internal block configuration example of an outline font processor (OFP) 80, which is a character generation LSI for performing a series of processes for converting the outline font data into dot font data.

The OFP 80 is a host interface 81 and a font input FIFO inside the host interface.
82, block 83 consisting of affine transformation block and line width correction block, FIFO084, curve interpolation block 85, F
It comprises an IFO 86, a line generation block 87, a dot memory 88, a fill BitBLT block 89, and a page memory interface 90. Host interface 81
Outputs an address bus, a data bus, and a control signal group connected to the system bus on the system side. The internal data bus 91 is connected to the system data bus.
Further, a data bus 92 is connected from the font input FIFO 82 to a block 83 composed of an affine transformation block and a line width correction block. The page memory interface 90 outputs an address bus, a data bus, and a control signal group connected to the page memory controller on the system side.

[0005]

In the conventional character generator, the functions necessary for the series of processes for converting the outline font data into dot data are performed in block units, and each block is pipeline processed. Has achieved high-speed processing. Therefore, a block consisting of an affine transformation block and a line width correction block
83, curve interpolation block 85, line generation block 87
Each of the filled BitBLT blocks 89 had an execution unit (EU) composed of a register file, a multiplier, a shifter, an ALU and the like. In addition, it had an output data bus 92 for the font input FIFO 82. Further, the host interface 81 and the page memory interface 90 are provided so that data input and output with the system side are independent. Therefore, the overall size of the character generator increases, and in a relatively low-priced system, the cost of the character generator occupies the entire system.

Therefore, in a low-cost system, attention has been paid to changing the architecture of the character generation device from one function / one block to a plurality of functions / one block. First,
For a control that executes multiple functions, by constructing a common EU composed of the minimum number of primitives required for each operation, it is possible to reduce the scale of one block that realizes multiple functions. The size of the entire character generator can be reduced. Also, by connecting at least two or more of these blocks with a FIFO and performing pipeline processing in two stages, the optimum processing speed for the system can be realized.

An object of the present invention is to improve the quality of output characters by realizing the optimum processing speed for the system in a character generator for converting outline font data composed of character outline information into dot font data. Even if you add a character correction function for other purposes or add other functions,
It is an object of the present invention to provide a character generator that does not increase the scale of the entire device.

Another object of the present invention is to provide the above character generator suitable for LSI.

[0009]

In order to achieve the above object, a character generator according to the present invention includes a font input FIFO for temporarily storing outline font data from a CPU interface and a font memory, and a font input FIFO. The outline font data is read in order from and the coordinate data (x, y) is (x ',
FIFO for temporarily storing the vector block to be converted into y ') and the converted coordinate data (x', y ')
And raster data that reads the coordinate data from the FIFO and generates lines with dots between the coordinate data, the dot memory that stores the generated dot data, and the dot data that is read from the dot memory and fills the outline of the character. The raster block to be stored in the dot memory again is provided.

In the above character generator, the CPU interface receives data, addresses and control signals from the outside and supplies the data bus, address bus and control signals to the internal vector block and raster block, Font input FIF in block
The bus control and timing of reading data from O, reading and writing user registers in the vector block and raster block, and reading dot memory are controlled.

In the above character generator, the vector block is composed of a control unit and a calculation unit (execution unit), and depending on the character size to be output,
Line width correction that corrects the widths of all the lines that make up a character, affine transformation that performs coordinate conversions such as enlargement, reduction, and rotation of characters, and even correction of the line widths of horizontal and vertical lines of characters. During line width correction, curve interpolation that generates a curve with a short vector for curve data and address calculation that calculates the address of the dot memory when expanding on the dot memory for the head data of the loop that makes up the outline font data are performed. It is something to do.

In the above character generator, the raster block is composed of a control unit and a calculation unit (execution unit), and generates a line between dots of coordinate data and a character generated by the line generation. It is to fill the inside of the outline, control the dot memory for expanding characters, and clear the dot memory.

In the above character generator, a FIFO is provided between the vector block and the raster block,
The vector block and raster block operate in parallel.

In the above character generator, the dot memory is read by reading the address from the CPU with one address as in the case of the user register, and the address of the dot memory is sequentially incremented inside the character generator. Is.

[0015]

According to the above means, the font input FIFO for temporarily storing the outline font data from the CPU interface and the font memory, and the outline font data are sequentially read from the font input FIFO, and the coordinate data (x, y) is read. For (x ',
FIFO for temporarily storing the vector block to be converted into y ') and the converted coordinate data (x', Y ')
And raster data that reads the coordinate data from the FIFO and generates lines with dots between the coordinate data, the dot memory that stores the generated dot data, and the dot data that is read from the dot memory and fills the outline of the character. Since the raster block to be stored in the dot memory again is provided, the optimum processing speed for the system can be realized and the scale of the entire character generating device can be reduced.

According to the above means, the CPU interface receives the data, the address and the control signal from the outside and supplies the data bus, the address bus and the control signal to the internal vector block and the raster block,
Data bus from block to block, because it controls data read from font input FIFO in vector block and read / write of user register in vector block and raster block and read / write bus control and timing control. The number of address buses and control signals can be reduced, and the overall size of the character generator can be reduced.

According to the above means, the vector block is composed of the control unit and the arithmetic unit (execution unit), and corrects the widths of all the lines forming the character in accordance with the size of the character to be output. Line width correction, affine transformation that performs coordinate conversion such as enlargement, reduction, and rotation of characters, line width correction that uniformly corrects the line widths of horizontal and vertical lines of characters, and generates curves with short vectors for curve data. It is possible to improve the output character quality by performing curve interpolation and address calculation to calculate the address of the dot memory when expanding it on the dot memory for the head data of the loop that makes up the outline font data. The size of the vector block can be reduced, and the size of the entire character generator can be reduced.

According to the above means, the raster block is composed of the control unit and the arithmetic unit (execution unit), and the line generation for generating lines with dots between the coordinate data and the character generation generated by the line generation. Since the inside of the outline is filled and the dot memory for expanding the character is controlled and the dot memory is cleared, the scale of the raster block can be reduced and the scale of the entire character generator can be reduced.

According to the above means, a FIFO is provided between the vector block and the raster block, and the vector block and the raster block operate in parallel, so that the optimum processing speed for the system can be realized.

According to the above-mentioned means, when reading the dot memory, the address from the CPU is read by one address as in the case of the user register, and the address of the dot memory is sequentially incremented inside the character generator. Therefore, it is possible to reduce the address and the load on the system side.

[0021]

EXAMPLES Examples of the present invention will be described in detail below.

FIG. 2 shows a system configuration example using a character generator for converting outline font data composed of character contour information into dot data. A CPU 11, a system memory 12, a character generator 1, a font memory 13, a printer 14, a keyboard 15 and a display 16 are connected to a system bus 17 including an address bus, a data bus and a control signal group. This system is mainly used for low cost word processors and CRT systems. For example, the CPU 1 reads out outline font data from the font memory 13 and writes it in the character generator 1. The character generator 1 sequentially converts the written outline font data into dot font data and expands it in a built-in dot memory. CPU11
The dot font data expanded in the dot memory of the character generator 1 is read out, transferred to the printer 14 or the display 16, and printed or displayed.

FIG. 1 shows a character generator 1 to which the present invention is applied.
It is a block diagram of. It should be noted that the present invention is not limited to this, and is not limited to the LS as a microcomputer peripheral.
It may be an I-shaped single element or a systemized device.

Here, the character generator 1 includes a CPU interface 2 and a font input FIFO 3, a vector block 4, and a FIFO inside the CPU interface 2.
It consists of 5, raster block 6, and dot memory 7. An address bus, a data bus, and a control signal group connected to the system bus are input and output from the CPU interface 2.

FIG. 3 is a block diagram of the vector block 4. The vector block 4 is composed of a control unit 21 and a calculation unit (execution unit) 22. The control unit 21 includes a line width correction 123 that corrects the widths of all the lines that form a character according to the size of the output character, and an affine transformation 24 that performs coordinate conversion such as enlarging, reducing, and rotating the character. , A line width correction 225 that uniformly corrects the horizontal and vertical line widths of characters, a curve interpolation 26 that generates a curve with a short vector for the curve data, and a dot for the beginning data of the loop that forms the outline font data. Memory Dot memory when expanding to Article 7
It is a control group that performs address calculation 27 that calculates the address of 7.

FIG. 8 is a block diagram of the execution unit 22 in the vector block 4. The execution unit 22 is composed of two buses, an A bus 401 and a B bus 402, and has a register file 403 and a multiplier 40.
5, the output latches 406 and 407 of the multiplier, the input latches 408 and 409 of the ALU, the ALU 410, and the output latch 411 of the ALU are connected as shown. Bus configuration is 3
You may take the structure more than a bus. Table 404 stores Bezier curve interpolation coefficients. This is RO
It is composed of M, RAM, PLA, register file, logic and the like.

FIG. 4 is a block diagram of the raster block 6. The raster block 6 is composed of a control section 31 and a calculation section (execution unit) 32. The control unit 31 generates a line 33 that generates a line with dots between coordinate data and a fill 34 that fills the outline of the character generated by the line generation.
And a dot memory control for clearing the dot memory and a dot memory control / clear 35 control group for clearing the dot memory.

FIG. 9 is a block diagram of the execution unit 32 in the raster block 6. The execution unit 32 is composed of two buses, an A bus 412 and a B bus 413, and has a register file 414 and an ALU 41.
5, ALU output latch 416, fill logic 417
Are connected as shown. The bus configuration may be three or more.

FIG. 5 is a block diagram of the dot memory 7. Further, the dot memory 7 is composed of a dot memory cell 38 and an address generation counter 37. In the character generator 1, the dot memory 7 is read out by providing an address generation counter 37 and reading the address of the dot memory 38 so that the address from the CPU can be read by one address as in the case of the user register. It was made to increment sequentially.

Next, the operation of the character generator according to the present invention will be described.

6 and 7 are process flowcharts showing the operation of the character generator.

In FIG. 6A, the CPU 11 clears the dot memory 7 in the character generator 1. Therefore, the raster block 6 in the character generator 1 is 601
Then clear the dot memory 7. After the completion of clearing, the CPU 11 waits for activation from the CPU 11 at 602.

Next, in FIGS. 6B and 7C, C
PU11 activates the character generator 1. Character generator 1
The vector block 4 and the raster block 6 in the inside start operating simultaneously.

The vector block 4, at 603, reads the outline font data from the font input FIFO 3. At 604, the read data is subjected to line width correction 1 for correcting the widths of all the lines forming the character in accordance with the output character size. Next, at 605, affine transformation is performed to perform coordinate transformation such as enlargement, reduction, and rotation of characters. Next, in step 606, a line width correction 2 for uniformly correcting the horizontal and vertical line widths of the character is executed. Next, in 607, if the processed data is the start point of the loop forming the outline font data,
At 608, address calculation is performed to calculate the address of the dot memory when expanding on the dot memory. Then 6
In 09, if the processed data is curve data,
At 610, curve interpolation is performed to generate a curve with the short vector. Finally, in 611, the processed data is transferred to the FIF.
Write to O 5. This series of processing is repeatedly executed.
Also, line width correction 1 604, affine transformation 605, line width correction 2
The processing order of 606 and curve interpolation 610 may be changed.

Raster block 6 is a vector block
When 4 writes the processed data to the FIFO 5, the data is read from the FIFO 5 at 612. At 613, line generation is performed for the read data to generate lines with dots between coordinate data. Then 6
At 14, the generated data is written to dot memory 7.
This series of processing is repeatedly executed, the data for one character is processed in 615, and when it is finished, the line is generated in 616.
Execute the filling to fill the inside of the outline of the character generated in the dot memory 7 by 13. Finally, 617
Then, the operation of the character generator 1 ends.

Next, each process of the operation process flowchart of the character generator described in FIGS. 6 and 7 will be described.

First, the line width correction 1604 for correcting the widths of all the lines forming a character will be described. Figure 13
Is the outline font data coordinate data (x0,
y0) to (x17, y17). A character outline 57 is formed by this coordinate data. When this character is reduced, the character is crushed and the character quality deteriorates. To prevent this, it is necessary to correct the outline of the character in advance and reduce the line width of the entire character before reducing the character, as shown at 58. To this end, the coordinate data forming the contour is corrected. For example, coordinate data (x2,
In order to convert y2) into (x'2, y'2), the following calculation is performed.

[0038]

## EQU1 ## x'2 = x2-dxpx y'2 = y2 + dypx The operation is executed by the execution unit 22 of the vector block 4. A calculation example will be described in the execution unit 22 shown in FIG. It is assumed that x2 and y2 in the equation (Equation 1) are stored in xn and yn of the register file 403. The correction amounts dxpx and dypx are also stored in the register file 403 in advance. Therefore, in a certain state of this operation, x2 is read by the A bus 401 and latched by the input latch 408 of the ALU, and dxpx is read by the B bus 402 and A x.
It is latched in the LU input latch 409. In the next state, the operation of x2-dxpx is executed by the ALU 410, and the operation result x'2 is latched in the output latch 411 of the ALU. Similarly, the calculation is executed for y'2. Therefore, for all coordinate data,

[0039]

## EQU2 ## The calculation of x'n = xn ± dxpx y'n = yn ± dypx is performed.

At this time, as a method of determining the correction direction (±) and the correction amounts dxpx and dypx,
There is a method of adding an attribute to each coordinate data. Alternatively, the correction direction and the correction amount may be determined from the coordinate data before and after the coordinate data to be corrected. Further, when the character is enlarged, the character becomes poor and the character quality deteriorates. To prevent this, it is necessary to thicken the line width of the entire character before enlarging the character. This may also be performed in the same manner as the above-described processing for narrowing the line width of the entire character.

Next, the affine transformation 605 for performing coordinate transformation such as enlargement, reduction and rotation of characters will be described. Figure 10
Outline font data coordinate data (x0, y
0) to (x11, y11). A character outline 51 is formed by this coordinate data. Coordinate data (x'0, y ') is obtained by reducing this character by affine transformation.
0) to (x'11, y'11) are the characters of the contour 52. The affine transformation performs the following operations.

[0042]

## EQU3 ## x'n = Axn + Byn + tx y'n = Cxn + Dyn + tY The operation is executed by the execution unit 22 of the vector block 4 which is the same as the line width correction 1 described above. A calculation example will be described in the execution unit 22 shown in FIG. The register file 403 has affine matrix data A, B, C, D, tx, ty and coordinate data xn,
It is assumed that yn is stored.

Therefore, in the state with this operation, A
Is read and held by A bus 401, xn is B bus
The lead is held by 402. After the next state, the data held on the bus is multiplied by the multiplier (MULT), and the multiplication result Axn is obtained by the multiplication output latch 406.
And 407, further read by the B bus, and latched by the input latch 409 of the ALU. Similarly, the multiplication result Byn is latched in the input latch 408 of the ALU. In the next state, the addition result Axn + Byn is latched by the ALU 410 in the output latch 411 of the ALU. In the next state, Axn + Byn is read to the A bus and latched in the input latch 408 of the ALU,
tx is read by the B bus and the input latch of ALU 409
Latched on. In the next state, the ALU 410 executes Axn + Byn + tx, and the addition result x ′ is latched in the output latch 411 of the ALU. Similarly, y '
The affine transformation is also executed for n.

Next, the line width correction 2606 for uniformly correcting the horizontal and vertical line widths of a character will be described. Figure 11
Outline font data coordinate data (x0, y
0) to (x11, y11). A character outline 53 is formed by this coordinate data. In this example, the contour formed by the coordinate data (x4, y4) and (x7, y7) causes unevenness of the horizontal line of the character. Therefore, the following calculation is performed to correct the contour 54 of the character to make the horizontal line of the character uniform.

[0045]

[Mathematical formula-see original document] y'4 = y9 + dypa The arithmetic operation is executed by the execution unit 22 of the vector block 4, which is the same as the above-mentioned line width correction 1 and affine transformation.

Therefore, regarding the coordinate data to be corrected,

[0047]

## EQU5 ## The calculation of x'n = xn ± dxpa y'n = yn ± dypa is performed.

At this time, an attribute is added in advance to the coordinate data to be corrected, and the correction is executed.
Further, for data having the same value, the corrected data is inherited as it is.

Next, the address calculation 608 for calculating the address of the dot memory when the head data of the loop forming the outline font data is expanded on the dot memory will be described. FIG. 14 shows coordinate data (x0, y0) to (x11, of outline font data).
y11). With this coordinate data, the outline of the character
59 are formed. Also, the loop is (x0, y0)
~ (X7, y7) and (x8, y8) to (x11, y1)
It is composed of two loops of 1). Therefore, the address calculation is performed with coordinate data (x0, y0) and (x8, y
Calculate for 8). For example, an address on the dot memory is assigned to the dot memory address 72.
It is assumed that (x0, y0) corresponds to address 4 on the dot memory. This 4th address is calculated from x0 and y0. Also,
The bit address 73 is obtained by decoding x0 which one of the four addresses corresponds to. This address calculation is executed by the execution unit 22 of the vector block 4, which is the same as the above line width correction 1, affine transformation, and line width correction 2. The calculated address data is transferred to the raster block 6 via the FIFO 5 in the same manner as the outline font data.

Next, a curve interpolation 610 for generating a curve with a short vector for curve data will be described. Figure
12 is the coordinate data (x0, y0) to the coordinate data shown by the curve data in the coordinate data of the outline font data.
(X3, y3). Further, this curve is the cubic Bezier curve data 55. The coordinate data (x'0, y'0) to (x'3, y'3) generated by the curve interpolation form the outline 56 of the character. Curve interpolation performs the following operations.

[0051]

[Mathematical formula-see original document] x'n = C0x0 + C1x1 + C2x2 + C3x3 y'n = C0y0 + C1y1 + C2y2 + C3Y3 The operation is the same vector block as the above line width correction 1, affine transformation, line width correction 2, address calculation, and curve interpolation 4
Execution unit 22 of. Register file for execution unit 22 shown in Figure 8
Curve data (x0, y0) to (x3, y3) are stored in p0x, p0y, ~ p3x, p3y of 403. The table 404 stores C0 to C3. By selecting C0 to C3, the product-sum operation similar to the affine transformation is repeated, and the coordinate data (x '
0, y'0) to (x'3, y'3) are calculated.

Next, the line generation 613 for generating a line with dots between coordinate data and the filling 616 for filling the inside of the outline of the character generated by the line generation will be described. FIG. 14 is a character outline 71 generated on a dot memory by generating a line with dots between coordinate data 59, and FIG. 15 is a dot expanded on the dot memory again by filling the inside of the character outline 71. font
74. The calculation in line generation is performed in the execution unit 32 of the raster block 6. Further, the calculation in the filling is also executed by the execution unit 32 of the raster block 6.

[0053]

According to the present invention, in a character generator for converting outline font data composed of character contour information into dot font data, optimum processing speed for the system can be realized and high quality characters can be generated. can do.

Furthermore, in a series of outline font data processing, vector data conversion processing relating to coordinate conversion and raster data conversion processing relating to line generation and filling are divided into two blocks, and the execution unit provided in each block is a multiplier. , ALU, register file, latch, bus configuration, etc. are minimized, so that the overall size of the character generator can be reduced.

[Brief description of drawings]

FIG. 1 is a block diagram of a character generator.

FIG. 2 is a system configuration diagram using a character generation device.

FIG. 3 is an internal configuration diagram of a vector block.

FIG. 4 is an internal configuration diagram of a raster block.

FIG. 5 is an internal configuration diagram of a dot memory.

FIG. 6 is an operation processing flowchart of the character generation device.

FIG. 7 is a flowchart of an operation process of the same.

FIG. 8 is an execution unit diagram of a vector block.

FIG. 9 is an execution unit diagram of a raster block.

FIG. 10 is an explanatory diagram of affine transformation.

FIG. 11 is an explanatory diagram of line width correction 2.

FIG. 12 is an explanatory diagram of curve interpolation.

FIG. 13 is an explanatory diagram of line width correction 1.

FIG. 14 is an explanatory diagram of address calculation and line generation.

FIG. 15 is an explanatory diagram of filling.

FIG. 16 is a block diagram of a character generator.

[Explanation of symbols]

 1 ... Character generator, 2 ... CPU interface, 3 ... Font input FIFO, 4 ... Vector block, 5 ... FIFO, 6 ... Raster block, 7 ... Dot memory.

 ─────────────────────────────────────────────────── ─── Continued Front Page (72) Inventor Kazuko Hasegawa 292 Yoshida-cho, Totsuka-ku, Yokohama-shi, Kanagawa, Ltd. Microelectronics Devices Development Laboratory, Hitachi, Ltd. (72) Hiroshi Wada 292 Yoshida-cho, Totsuka-ku, Yokohama-shi, Kanagawa House number Hitachi, Ltd. Microelectronics equipment development laboratory (72) Inventor Yuko Sato 292 Yoshida-cho, Totsuka-ku, Yokohama, Kanagawa Prefecture Household number Hitachi Ltd. Microelectronics equipment development laboratory (72) Inventor Hiroaki Shirane Totsuka Yokohama, Kanagawa Prefecture 292 Yoshida-cho, Tokyo Stock company Hitachi Image Information Systems (72) Inventor Kazuhisa Nishimoto 292 Yoshida-cho, Totsuka-ku, Yokohama City, Kanagawa Stock company Hitachi Image Information Systems (72) Inventor Shigeo Hayashi Kamimizumoto-cho, Kodaira-shi, Tokyo 5 chome No. 20-1 Stock, Hitachi Ltd. Semiconductor Design and Development Center (72) Inventor Norio Kiriyama 1-1-1, Higashitaga-cho, Hitachi City, Ibaraki Hitachi Ltd. Taga Factory

Claims (6)

[Claims] 1. A character generator for converting outline font data composed of character contour information into dot font data, and a font input FIFO for temporarily storing the outline font data from a CPU interface and a font memory, Font input FIF
A vector block for sequentially reading outline font data from O and converting coordinate data (x, y) into (x ', y') and converted coordinate data (x ',
y ') for temporarily storing, a raster block for reading coordinate data from the FIFO and generating lines between the coordinate data with dots, a dot memory for storing the generated dot data, and a dot memory A character generation device comprising the raster block for reading dot data from a character, filling the outline of the character, and storing it in the dot memory again. 2. The character generator according to claim 1, wherein C
The PU interface receives data, address and control signals from the outside, supplies a data bus, address bus and control signals to the internal vector block and raster block, and reads data from the font input FIFO in the vector block. A character generator which controls bus control and timing of reading and writing of user registers in the vector block and raster block, and reading of dot memory. 3. The character generator according to claim 1 or 2, wherein the vector block comprises a control section and a calculation section (execution unit), and all the characters are formed in accordance with the output character size. Line width correction that corrects the line width of the character, affine transformation that performs coordinate conversion such as enlargement, reduction, and rotation of the character, line width correction that uniformly corrects the line width of the horizontal and vertical lines of the character, and curve data Characters that perform curve interpolation that generates a curve with a short vector and address calculation that calculates the address of the dot memory when expanding on the dot memory for the head data of the loop that constitutes the outline font data Generator. 4. The character generator according to claim 1, wherein the raster block is composed of a control unit and a calculation unit (execution unit), and a line generating line generating a line between the coordinate data and a line generating the line. A character generator characterized by performing filling for filling an outline of a character generated by generation, control of a dot memory for expanding a character, and clearing of the dot memory. 5. The character generator according to claim 1, wherein the vector block and the raster block operate in parallel. 6. The character generator according to claim 1 or 2, wherein the dot memory is read at a fixed address, and the address of the dot memory is sequentially incremented inside the character generator. Generator.