JPH0733104B2 - Compression and decompression method for dot matrix characters - Google Patents

Description

Description: TECHNICAL FIELD The present invention relates to a method for compressing dot-matrix characters suitable for storing a large number of dot-matrix characters in a character generator, and a method for decompressing the compressed characters.

BACKGROUND ART Conventionally, there have been printers that represent a single character using a large number of dots (for example, 24 dots vertically and 24 dots horizontally). This type of printer is called a dot printer, and among them, wire dot printers that print dots using wires are well-known. Generally, this type of dot printer is equipped with a character generator that stores data on whether or not to print dots (hereinafter abbreviated as dot data),
When printing a character, the dot data for the character to be printed is read from this character generator and the character is printed. For example, in the case of a wire dot printer with 24 wires arranged vertically, the dot data for one vertical row (24 dots) is read from the character generator multiple times to print one character.

In recent years, there has been a demand for printers to be able to print a wide variety of characters. To this end, a method has been invented for storing a large number of characters in a character generator. This invention is described in Japanese Patent Application Laid-Open No. 60-257253.
In the United States, it is described in US Pat. No. 4,704,040. This invention is a character compression method that reduces the amount of data per character by examining the arrangement of dots (hereinafter referred to as the dot pattern) for each column. If the same dot pattern is repeated multiple times, the dot data for one column and data indicating the number of repetitions are stored in a character generator. However, there are characters that cannot be compressed using this compression method. Such characters are shown in Figure 1. As can be seen from the figure, no two adjacent columns in the same row have dots. In other words, no horizontal dots are consecutive. Therefore, the dot patterns in two adjacent columns are always different, and no identical dot patterns are consecutive. This character was devised to improve printer print quality and speed. Therefore, it has more horizontal dots than normal characters. The letter [M] in the figure has 30 horizontal dots. As mentioned above, the dots are not consecutive horizontally. The reason for this is explained below.

In the case of a wire dot printer, when a wire is driven, it jumps out from its initial position, prints a dot on the printing paper at a specified position, and then returns to its initial position. If the same wire is driven again, it is driven after the wire has returned to its initial position. However, with normal characters, it is not clear what the dot pattern will be. Sometimes dots are continuous horizontally. Therefore, to ensure normal printing even in such cases, once a dot has been printed with a certain wire, other wires will not be driven until that wire has returned to its initial position. However, with this control method, the wires cannot be driven efficiently, and printing speed does not increase. This is because when a certain wire is driven, there are other wires that can be driven even if that wire does not return to its initial position. These wires are the wires that were not driven when printing the dots in the previous row. Therefore,
If the dot pattern of the characters is such that the dots are not consecutive in the horizontal direction, the wires can be driven efficiently and the printing speed can be increased, which is the reason mentioned above.

SUMMARY OF THE INVENTION It is therefore an object of the present invention to provide a method for compressing characters that cannot be compressed because the same dot patterns do not occur consecutively, in a simple manner, and a method for decompressing the compressed characters.

Disclosure of the Invention In the present invention, before compressing a character, dots are added to create a character with a continuous identical dot pattern. This character is then compressed and stored in a character generator. When printing a character, this compressed character is read from the character generator and expanded to restore the character before compression. Furthermore, from this expanded character,
Remove the dots added during compression.

This allows characters that cannot be compressed because the same dot pattern does not occur consecutively to be compressed in a simple manner.

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a diagram showing an example of a character in which the same dot pattern is not continuous, FIG. 2 is a diagram showing a character in which dots are added to the character in FIG. 1 so that the same dot pattern is continuous, FIG. 3 is a diagram showing stored data in a character generator, FIG. 4 is a diagram showing a control circuit of a printer, FIG. 5 is a flowchart showing expansion processing, and FIG. 6 is a diagram showing a control circuit for removing the added dots.

Best Mode for Carrying Out the Invention First, the compression method will be described.

Figure 2 shows the character [M] in Figure 1 with a dot [○] added. This dot [○] is added only to make the same dot pattern continue, and is removed before printing. This dot [○] is added if there is a printing dot [●] in the column immediately preceding the same row. However, if the dot is added but the same dot pattern does not continue, it is not added. In the case of this character [M], columns 2, 4 to 7 are
Adding a dot [○] to the dot patterns in columns 8, 15, 24-28, and 30 would result in a series of identical dot patterns, so a dot [○] is added. However, adding a dot to the dot patterns in columns 8-14 and 17-23 would not make them identical to the dot patterns in the adjacent columns, so no dots are added to these columns.

Here, we will explain with reference to Figure 3 what happens to the data stored in the character generator when the character in Figure 2 is compressed using the compression method described above. The character generator is a memory that can store 8 bits of data per address.

FIG. 3 shows the data stored in the character generator.
However, the stored data is shown in a dot matrix format to make it easier to imagine the printout.
The numbers 1 to 24 on the left side of the figure are row numbers.
Also, ...
The row data and address stores data from rows 17 to 24 in the first column, and the address stores data from rows 1 to 8 in the second column. The same applies to the other addresses.

The data stored in the character generator is dot data and data indicating the number of repetitions. The dot data is data for rows 1 to 19 of each column shown in FIG.
In FIG. 3, dot data is shown as [●] and blank spaces.
[●] indicates that a dot will be printed in that area,
A blank space indicates that no dot will be printed in that area. The character generator stores binary data: [1] for [●] and [0] for blank spaces. For example, the data stored in the character generator address is an 8-digit binary value: [00110000]
(dot data for lines 1 to 8 of the first line). Similarly, the address is stored as an 8-digit binary number [00
111111] (dot data from rows 1 to 8 of the second column). On the other hand, the data indicating the number of repetitions is the data from rows 20 to 24 of each column shown in Figure 3. The character generator stores binary data [1] corresponding to [◎] and [0] corresponding to a space. The data indicating the number of repetitions is a binary 5 notation with the data from row 20 as the most significant bit.
For example, the data indicating the number of repetitions in the first column of Figure 3 is [00010], which is a decimal number [2]. Similarly, the data in the second column is [00011], which is 1
The decimal number is [3].

Next, a method for expanding compressed characters will be described.

The control circuit of the printer is shown in FIG.
is a CPU that controls the entire printer, 2 is a ROM that stores the programs executed by CPU 1, 3 is a RAM for storing data, 4 is an I/O driver, 5 is an interface circuit for connecting the printer to an external device, 56 is a print head, 7 is a line feed motor for transporting the print paper, and 8 is a spacing motor for spacing the print head 6 left and right. Although a character generator is not shown, it is located in ROM 2 or RAM 3.

Figure 5 is a flowchart for decompressing compressed characters. The decompression process shown in this flowchart is executed by CPU 1 in Figure 4 in accordance with a program stored in ROM 2. The decompression process will be explained below in accordance with this flowchart. However, in the following explanation, it is assumed that various counters and flags are stored in RAM 3 in Figure 4.

First, in step S1, the address counter ADRCT
A predetermined address is set in (1). This address is the address of the character generator, and is the top address of the memory area where the dot data of the character to be read is stored. For example, it is the address in Figure 3. Also, a predetermined address is set in the address counter ADRCT (2). This address is the address of RAM3, and is the top address of the memory area where the expanded dot data is stored. Furthermore, [3
0]. This column counter CLMCT is used to determine whether the decompression process for one character has finished. In this case, the last column of one character is column 30 (see Figure 2).
Therefore, set [30]. Furthermore, set flag F to [1].
This flag F is set to the repeat counter (described later) which counts the number of times the character is fed out from the character generator.
This is to determine whether to set the number of repetitions in the CYCCT, and only when [1] is set, the number of repetitions is set in the repeat counter CYCCT.

Next, in step S2, the address counter ADRCT
(1) and reads out dot data from the character generator. The third address is written to the address counter ADRCT(1).
If the address shown in the figure is set, the dot data [00110000] of the first row to the eighth row of the first column in FIG. 3 is read out.
The following description will be given assuming that the address shown in FIG. 3 is set in the address counter ADRCT(1).

Next, in step S3, the address counter ADRCT
This dot data is written to RAM3 by referring to (2).
Then, the address counter ADRCT(2) is incremented.

Next, in step S4, the address counter ADRCT
Increment (1).

Next, in step S5, the address counter ADRCT
By referring to (1), dot data is read from the character generator. As a result, the 9th row of the 1st column in FIG.
Read out 16 lines of dot data [00000000].

Next, in step S6, the address counter ADRCT
This dot data is written to RAM3 by referring to (2).
Then, the address counter ADRCT(2) is incremented.

Next, in step S7, the address counter ADRCT
Increment (1).

Next, in step S8, the address counter ADRCT
By referring to (1), dot data is read from the character generator. As a result, the 17th row of the 1st column in Figure 3
Read the 24th row of data [01100010]. However, the bottom 5
Bits [00010] are data indicating the number of repetitions.
Here, the number of repetitions is two.

Next, in step S9, it is determined whether flag F is set to [1].
Since flag F is set to [1] in step S10, the result of the determination is YES, and the process proceeds to step S10.

Next, in step S10, flag F is set to [0].

Next, in step S11, the number of repetitions read out in step S8 is set in the repetition counter CYCCT. In this case, since the number of repetitions is two, [2] is set.

Next, in step S12, the address counter ADRCT
With reference to (2), the dot data read out in step S8 is written to RAM 3. However, the bottom five bits (data indicating the number of repetitions) are written as [00000].
As a result, the dot pattern of the first row in Fig. 2 is stored in RAM 3. Then, the address counter ADRCT(2) is incremented.

Next, in step S13, the column counter CLMCT is decremented, so that the value of the column counter CLMCT becomes [29].

Next, in step S14, it is determined whether the value of the repeat counter CYCCT is [0].
In step S1, the repeat counter CYCCT is set to [2], so the result of the determination is NO, and the process proceeds to step S18.

Next, in step S18, the repeat counter CYCCT is decremented.
The value of T is [1].

Next, in step S19, the address counter ADRCT
[2] is subtracted from (1). As a result, the value of the address counter ADRCT (1) returns to the original value. In other words, it returns to the value at step S2, which has already been executed.

Next, the processing of steps S2 to S12 is executed again. At this time, the value of the address counter ADRCT(1) is restored to the original value, so the dot data of the first column in FIG. 3 is read out from the character generator again and written to RAM 3. As a result, the dot data of the second column in FIG. 2 is stored in RAM 3. However, the result of the determination in step S9 is
The result is NO, and the processes in steps S10 and S11 are not executed. Therefore, the value of the repeat counter CYCCT is not updated and remains at [1].

Next, the processes of steps S13 to S19 are executed. At this time, the value of the repeat counter CYCCT is [1], so
The result of the determination in step S14 is NO. As a result, the value of the column counter CLMCT is set to [28], and the value of the repeat counter CYCCT is set to [0].
The value of the address counter ADRCT becomes [0].
The value of (1) returns to the original value.

Next, the processing of steps S2 to S12 is executed again. At this time, the value of the address counter ADRCT(1) has returned to the original value, so the dot data of the first column in FIG. 3 is read out from the character generator again and written to RAM 3. As a result, the dot data of the third column in FIG. 2 is stored in RAM 3. However, the result of the determination in step S9 is
The result is NO, and the processes in steps S10 and S11 are not executed. Therefore, the value of the repeat counter CYCCT is not updated and remains at [0].

Next, the processes of steps S13 to S17 are executed. At this time, the value of the repeat counter CYCCT is [0], so
The result of the determination in step S14 is YES. As a result, the process in step S15 is executed, and the flag F is set to [1] again. Furthermore, the value of the column counter CLMCT is set to [2
7], the result of the determination in step S16 is NO, so the process in step S17 is executed and the address counter ADRCT(1) is incremented.

Next, the processing of steps S2 to S12 is executed again. At this time, the value of the address counter ADRCT(1) has been updated, so this time the dot data of the second column in FIG. 3 is read from the character generator and written to RAM3. As a result, the dot data of the fourth column in FIG. 2 is stored in RAM3. However, the result of the determination in step S9 is YES, and the processing of steps S10 and S11 is executed. As a result, flag F is set to [0],
The repeat counter CYCCT is set to [3]. The repeat counter CYCCT is set to [3] on the third
This is because the number of repetitions in the second column is three, as shown in the figure.

Thereafter, the processing of each step is executed until the value of the column counter CLMCT becomes [0]. When the value of the column counter CLMCT becomes [0], the determination result of step S16 becomes YES, and the decompression processing for one character ends. As a result, the dot data shown in Figure 2 is stored in RAM 3.

Next, the process of removing the dots [◯] in FIG. 3 will be described.

FIG. 6 shows the control circuit that executes this process.
This process may be executed by the CPU 1 shown in FIG. 4 in accordance with a program stored in the ROM 2.
denotes an AND circuit, 10 denotes a storage device that stores the output data of the AND circuit 9, and 11 denotes a NOT circuit that inverts the output data of the storage device 10.

Next, the operation of this control circuit will be explained. However, it is assumed that the contents of the memory device 10 have been cleared to [0] in advance. Also, it is assumed that the expanded dot data shown in Figure 2 is stored in RAM 3 in Figure 4.

First, the dot data (24 bits) of the first column in FIG. 2 is read from RAM 3 and input to input terminal B of AND circuit 9. If the numbers 1 to 24 on the left side of FIG. 3 are bit numbers, then
Data with bits 1, 4, 18, and 19 set to [1] is ANDed.
At this time, as described above, the memory device 10
All bits of the output data (24 bits) of the AND circuit 9 are [0], and all bits of the output data (24 bits) of the NOT circuit 11 are [1].
The data in which all bits are [1] is input to the register.
Therefore, the same data as that input to input terminal B is output from AND circuit 9. In other words, the dot data for the first column in Figure 2 is output. This output data is then stored in RAM 3 in Figure 4, and when printing, it is read from RAM 3 and sent to print head 6 via I/O driver 4. However, it is assumed that RAM 3 in Figure 4 has an area for storing this output data. For example, it is assumed that an area is prepared that can store dot data for one printing line. The output data of AND circuit 9, that is, the dot data for the first column in Figure 2, is also stored in memory device 10. As a result, data that is the inverse of the dot data for the first column in Figure 2 is input to input terminal A of AND circuit 9. In other words, data with bits 3, 4, 18, and 19 set to [0] is input to input terminal A of AND circuit 9.

Next, the dot data (24 bits) of the second column in Fig. 2 is read from RAM 3 and input to input terminal B of AND circuit 9. At this time, data with bits 3, 4, 18, and 19 being [0] is input to input terminal A of AND circuit 9. Therefore, the dot data of [○] in the second column in Fig. 2 is removed by AND circuit 9. As a result, data with all bits being 0 is output from AND circuit 9. Thereafter, this data is stored in RAM 3 and in storage device 10 as described above. In this way, AN
The D circuit 9 removes the dot data of [◯] in all columns in Fig. 2. Then, the dot data for printing is stored in the RAM 3.

The compression and decompression process has been described above using the character [M] as an example.

However, the dot patterns of characters used in printers vary. For example, there are characters such as the lowercase letter [j] whose dot data exists between lines 20 and 24 in Figure 3, and data indicating the number of repetitions cannot be stored. Therefore, this character is not compressed.
There are some characters that are better compressed even if the data indicating the number of repetitions cannot be stored between rows 1 and 24. For such characters, the data per column (dot data and data indicating the number of repetitions) is stored in four addresses in the character generator. In other words, the dot data is stored in three addresses and the data indicating the number of repetitions is stored in one address.

In this way, the compression method differs depending on the character.
It is necessary to identify the compression method. Therefore, printers to which this invention is applied are designed to be able to identify the compression method for each character. For this purpose, they have a management table that stores character management information. This management table is in ROM2 in Figure 4. It stores data that identifies the compression method. It also stores address data (starting address) that indicates which address in the character generator the dot data for that character is stored at. In addition, various other data related to the character is stored.

INDUSTRIAL APPLICABILITY As described above, the present invention is suitable for compressing characters that cannot be compressed because the same dot patterns do not occur consecutively.

Claims (3)

[Claims] [Claim 1] A method for compressing dot-matrix characters that are configured so that no two columns of dots are consecutive in the same row, comprising the steps of: adding a dot to a column in the same row where a dot already exists, in order to create a dot-matrix character with multiple columns of the same dot pattern, thereby creating a dot-matrix character with two columns of consecutive dots in the same row; and, in the case of multiple columns of the same dot pattern, storing one column of the dot pattern and the number of times this dot pattern is repeated in the character generator, in order to compress and store the dot-matrix character in a character generator. [Claim 2] A method for compressing dot-matrix characters as described in claim 1, characterized in that even if a dot is added, if the dot pattern of the column to which the dot is added does not become identical to the dot pattern of the adjacent column, no dot is added. [Claim 3] A method for reading out and decompressing a dot-matrix character that has been compressed and stored in a character generator by the steps of: adding a dot to a column in which a dot exists in the column immediately preceding the same row to create a dot-matrix character with two consecutive columns of dots in the same row; and, if the same dot pattern occurs in multiple consecutive columns, storing in the character generator a dot pattern for one column and the number of times this dot pattern is repeated, wherein the method for decompressing a dot-matrix character comprises the steps of: reading out the same dot pattern the number of times stored in the character generator to restore the compressed dot-matrix character to the dot-matrix character before compression; and removing dots from a column in which a dot exists in the column immediately preceding the same row to remove the dots added during compression.