JPH07239942A - Method and device for generating pattern - Google Patents

Abstract

PURPOSE:To eliminate the need for complicated processing such as expansion processing by dividing a character symbol pattern into sub matrices, reading a sub matrix based on each of index information group specifying the sub matrices and generating a character pattern, and to obtain a high efficiency. CONSTITUTION:Let one character pattern be a dot size of 48X48 and a sub matrix be a dot size of 48-dots of one longitudinal column, that is, 6 bytes, then one character pattern consists of 48 sub matrices. Upon the receipt of print data via an I/F 7 from a host computer, a CG ROM 5 is referred for a pattern corresponding to a character code in the received data. The pattern is expanded in a bit map memory 5, the processing above is sequentially repeated for one page of bit map expansion processing, then the resulting data are provided as an output to a printer engine 4. Thus, the entire information quantity is reduced and a pattern for the character and symbol is generated at a sufficient processing speed.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a pattern generating apparatus and method, and more particularly to a pattern generating apparatus and method for generating a pattern for a character code.

[0002]

2. Description of the Related Art In recent years, various characters (for example, Mincho type,
It is possible to use Gothic font, Hosyo Mincho font, cursive font, etc.).

However, one type of character has thousands of characters as a whole, and even if the same type of character has a different size, it needs to be stored separately, so that it has a huge memory capacity.

Therefore, various compression techniques have been proposed, and it is desired to reduce the storage capacity.

It is common to apply compression by run length, but since this takes time for decompression processing, for example, a system for displaying and editing characters on an editing screen requires a high-speed CPU or the like. .

[0006]

Therefore, it is desirable to suppress the amount of information as a whole while storing the pattern in a non-compressed state.

Therefore, the following can be considered.

First, when one character pattern is represented by a dot pattern of M rows and N columns, m × n (m ≦ M, n ≦
M) sub-matrix pattern (hereinafter simply referred to as a sub-matrix), and a predetermined number of symbols is assigned to each sub-matrix. Then, the sub-matrix pattern is separately stored for each code number, and as a result, the character pattern is compressed and managed.

When a character pattern is managed by the above method, it is more efficient than when it is stored and managed by the total number of bits of the character pattern itself, and complicated processing such as decompression processing is not required Is also excellent.

[0010]

[Means for Solving the Problems] and

The present inventor proposes a pattern generating apparatus and method which further improve such a technique and have a sufficient processing speed while reducing the information amount as a whole.

In order to solve this problem, the pattern generator of the present invention has the following structure. That is, M ×
Character pattern of N dots is m × n (m ≦ M, n ≦
N) Sub-matrix storage means for subdividing into a dot sub-matrix and arranging and storing possible patterns of the sub-matrix, and for forming a character pattern corresponding to the character symbol for each character symbol code And an index information storage unit that stores an index information group that specifies each sub-matrix, extract the index information group corresponding to a given character symbol code from the index information storage unit, and extract the index information group of the extracted index information group. A pattern generator for individually reading out a corresponding sub-matrix from the sub-matrix storage means to generate a character symbol pattern, wherein the sub-matrix storage means has a portion in which significant dots of the pattern of the sub-matrix are present. Memorize the According the order corresponding to the location of bets, the with the contents of the index information, a significant pattern length stored is ready to be discriminated.

According to the structure of such a device, since the sub-matrix stores the significant dots, it becomes possible to further improve the memory efficiency.

Here, it is preferable that the sub-matrix storage means performs an exclusive OR operation between adjacent sub-matrices forming a character symbol pattern and stores the sub-matrix after the logical operation. This is because, as a result, the number of sub-matrices that can be taken can be reduced.

The size of the sub-matrix is 1
The sub-matrix storage means having a bit width,
When the range of byte units having non-output dots is continuous from the upper or lower direction of the sub-matrix pattern, it is desirable to exclude the continuous byte portion from being stored. As a result, the processing becomes information on a one-dimensional unit basis, and the processing is simplified, so high speed is desired.

In addition, in another invention, in consideration of both a character pattern having a good compression rate and a character pattern having a poor compression rate, a pattern having a high compression rate or a character pattern having a low frequency of use is compressed to reduce the processing speed. An object and an object of the present invention are to provide a character pattern generation device and method capable of storing compressed character patterns and non-compressed character patterns in a mixed manner while making the memory efficiency advantageous.

In order to solve this problem, for example, the pattern generator of the present invention has the following structure. That is, a storage means for storing a compressed character / symbol pattern and an uncompressed character / symbol pattern in a mixed manner is provided, and a corresponding compressed character pattern or non-compressed character pattern is stored from the storage means based on a given character / symbol code. A pattern generation device for reading and decompressing a compressed character pattern and outputting the compressed character pattern, the discrimination information storing means storing information for discriminating a character symbol code of a compressed character symbol pattern, and the discrimination information storage. The judgment means for judging whether or not the pattern corresponding to the given character / symbol code is compressed by referring to the means, and the judgment result of the judgment means, the character / symbol pattern for the focused character / symbol code is compressed. And a decompressing unit that decompresses the information read from the storage unit.

Still another object of the present invention is to provide a pattern generating device and device for generating a pattern at a higher speed than the above-mentioned invention while storing compressed character patterns and non-compressed character patterns in a mixed manner. .

In order to achieve this object, for example, the pattern generator of the present invention has the following structure. That is, the compressed character / symbol pattern and the non-compressed character / symbol pattern are mixed and continuously stored, and the corresponding compressed character pattern is stored from the pattern storage means based on a given character / symbol code. Alternatively, a pattern generator for reading out an uncompressed character pattern and decompressing and outputting the compressed character pattern, which corresponds to the order of patterns stored in the pattern storage means and corresponds to each character symbol code. Address storage means for storing the storage destination address of the storage means, and, when a character / symbol code is given, an address for extracting the storage destination address of the character / symbol code and the next character / symbol code from the address storage means Based on the difference between the extracting means and the address extracted by the extracting means, the character code Pattern corresponding to the soil and a determination unit for determining whether it is compressed.

[0019]

Embodiments of the present invention will be described in detail below with reference to the accompanying drawings. In addition, in the embodiment, an example applied to a printing apparatus will be described, but as will be apparent from the following description,
The present invention is not limited to this, as it can be applied to a display device and other devices.

FIG. 1 shows the configuration of the printing apparatus of the embodiment. In the figure, 1 is a CPU that controls the entire apparatus, and 2 is a RAM used as a work area of the CPU.
INDNO, FAD of variables or pointer variables described later
DR, IADDR, and SCOUNTER are secured. Reference numeral 3 denotes an RO which stores the operation processing procedure of the CPU 1.
M and 4 are printer engines that actually perform print processing, and 5 is a bit map memory that expands bit map data to be output to the printer engine. Reference numeral 6 is a character generator ROM (hereinafter referred to as CGROM) that stores a character pattern, and 7 is an interface (I / I) for receiving print data from a host computer.
F). Reference numeral 8 is a shared bus (SB) for exchanging data between the units.

As print processing, when print data is received from the host computer via the I / F 7, the pattern corresponding to the character code in the received data is CGRO.
It is generated by referring to M6, and it is expanded in the bitmap memory 5. Thereafter, this is performed in order, and when the bitmap expansion processing for one page is completed (for example, when a page break command is received), it is output to the printer engine 4 to perform printing.

Since the above-mentioned processing is generally performed, further explanation is omitted, and the character pattern generation principle and the management principle in the embodiment will be described below with reference to FIGS.

As shown in FIG. 2, the CGROM 6 stores a font table portion for storing a fixed-length (three bytes in this embodiment) index number for the sub-matrix of the font pattern of each character, and the font table. There is an index table referenced by the index number.

In the embodiment, as shown in FIG. 3, it is assumed that one character pattern has a size of 48 × 48 dots, and the sub-matrix has one vertical row of 48 dots, that is, 6 bytes. Therefore, one character pattern is composed of 48 sub-matrices. However, it goes without saying that the sub-matrix may be constructed not in the vertical direction but in the horizontal direction.

There is a reason why a 3-byte index number can be assigned to one sub-matrix (6 bytes). Currently, all the characters used as Japanese are 8120 characters. Therefore, the total number of sub-matrices is 8120 × 48 = about 390,000. Of these patterns, different patterns were examined for the Mincho type, and it was found to be about 168,000 and less than half.

This number is 3 bytes (2 to the 24th power = about 16
It is a number that is well represented by one million.

Therefore, in the embodiment, 6 bytes of the sub-matrix pattern in one character pattern are represented by a 3-byte index (hereinafter, index number), and 1
One character pattern is stored and managed by 3 bytes × 48 (= 144) bytes. This is the font table in FIG. It suffices to store a 6-byte pattern corresponding to each index number in the index table, but in the embodiment, this pattern is realized with a variable length of 1 to 6 bytes. The principle will be described below.

Now, taking the character "A" as shown in FIG. 4 as an example, the value of each sub-matrix pattern is represented by 6 bytes as shown.

In this way, when sub-matrix patterns are sequentially examined for other characters, there are 168,000 patterns in total, as described above.

Here, it is assumed that the order of the extracted sub-matrix (6 bytes) is "Index Ta" in FIG.
FIG. 5 shows that 6 bytes are treated as one “numerical value”, the “numerical values” of the sub-matrix extracted from all the characters are arranged in ascending order, and the index numbers are assigned in order.

As a result, what can be understood is, for example, that the 3-byte index number is "00002ah".
If (h is a hexadecimal number) or less, of the 6 bytes of the sub-matrix pattern represented by it,
This means that the upper 5 bytes are always "00h", in other words, it is uniquely determined that the output dot (bit "1") is present only in the lower 1 byte.

In other words, whether or not there is a significant dot only in the lower 1 byte of the sub-matrix can be confirmed by checking whether or not the index number is below a certain value (index number N1 or less in FIG. 5). Become.

Similarly, it is possible to derive whether or not there is a significant dot only in the lower 2 bytes, and it is also determined whether or not there is a significant dot in the 3rd, 4th, 5th, and 6th bytes from the lowermost one. it can.

Then, it is no longer meaningful that the sub-matrix for the index number in FIG. 5 has all 6 bytes, and the index table can be as shown in FIG. Incidentally, FIG.
There is no index number "000000h" in
This is because it can be uniquely determined that all 6 bytes of the sub-matrix are “00h”.

As a result, when a certain index number of a certain character pattern is extracted, by comparing the extracted index number with N1 to N6 shown in FIG. 6, it is possible to determine how many significant bytes there are. . Therefore, from the index table, it is possible to know how many bytes of the sub-matrix pattern should be read and how many bytes of "00h" should be added to the head of the sub-matrix pattern.

As a result, when one character is composed of 48 × 48 dots (= 288 bytes), one character is 3 ×
It can be managed with 48 (= 144 bytes), and it is not necessary to have a submatrix corresponding to each character's index number with all 6 bytes, and even a variable length will be stored and managed, so the total amount of information will be Can be reduced.

When comparing FIG. 5 and FIG. 6, the number of bytes deleted in the latter is 6 × 1 + 5 × (2Ah-1) + 4 × (21Bh-2A
h) + 3 × (867h-21Bf) + 2 × (1EAEh
−867h) + 1 × (8637h−1EAEh) = AF
It becomes 92h (= 44,946) bytes.

To generate the CPU 1 by referring to the CGROM 6, the CPU 1 performs the processing according to the processing procedure shown in FIG. The apparatus according to the embodiment externally follows the JIS code, for example, but internally uses the internal character code for processing. The reason is that the processing can be simplified and the speed is somewhat advantageous. However, the present invention is not limited to this. Also,
The technology itself for converting a character code into another code system is publicly known, and it may be considered in the same manner as the conversion between a kuten code and a JIS code, for example.

First, in step S100, the CPU 1 determines the existence position address FADDR of the font data (index number) corresponding to the character code to be generated.
Is obtained by the following formula.

FADDR ← start address of font table + character code to be used × 3 × 48 The character code to be generated is multiplied by “3” and further multiplied by “48” because each index number is the above This is because it is 3 bytes as described above, and there are 48 index numbers for each character.

Next, in step S101, the variable SC
"48" is set as the initial value in OUNER. This variable SCOUNTER is a variable for controlling the number of loops described below, and corresponds to the number of index numbers.

Next, in step S102, the address indicated by FADDR in the font table is set to 3
Fetch the byte and store it in the variable INDNO.

Hereinafter, in steps S103 to S108, the values N5 to N1 and 0 are compared, and if the respective conditions are satisfied, the process branches to steps S109 to S118.

For example, when the value stored in INDNO is larger than "0" and N1 or less (step S1).
18), the upper 5 bytes of the sub-matrix specified by INDNO is null data "00h", and the amount of data to be read is only 1 byte.

Then, from index table 1
Although byte data is taken out, its address position IADDR is obtained by the following equation.

IADDR ← start address of index table + INDNO-1 Thus, address IADD
In this case, one byte is taken out from the position indicated by R, and five null data "00h" are added in front of it and output.

Incidentally, when the index number stored in INDNO is "000000h", the sub-matrix can be unconditionally judged to be 6 null data (step S109).

INDNO is larger than N1 and N2
In the following case, as shown in step S117, the read address IADDR is IADDR ← N1 address + 1 + (INDNO-N1-
1) × 2.

The reason why the offset address is doubled is that
This is because significant data is 2 bytes in this section.

Further, N2 to N3, N3 to N4, N4 to N
It will be apparent from the equations shown in FIG. 7 and the above contents regarding the sections of 5 and N5 or more.

Now, when the generation of one sub-matrix is completed, the process proceeds to step S110. Here, since the next sub-matrix is generated, the address FADDR for reading the next index number is incremented by "3".

Since the generation of one sub-matrix has been completed by the above processing, the variable SCOUNT
Decrement the content of TER by "1" (step S
111).

Hereinafter, until it is determined that the content of SCOUNTER has become "0" (step S112),
The processing from step S102 onward is repeated.

Next, a practical example will be described.

The internal character code for the character "A" is "1".
410 ". At this time, the font table and the index table are as shown in FIG.

First, in step S100, 1410 × 3 × 4
8 is calculated, and FADDR indicates the first data of "A".
Next, in step S101, the number of slices of "A" (the number of index data) is set to "4" in step SCOUNTER.
8 "is stored. Next, in step S102, 3 bytes are acquired from the address pointed to by FADDR and stored in INDNO. Steps S103, S104, S105, S10.
6, S107, INDNO is N5, N4, N respectively
It is determined whether or not it is greater than 3, N2, N1. In this case, the index number of the first slice is 0000000.
Since it is 8h, all the judgment results are false,
In step S108, it is determined whether INDNO is equal to 0.

At this time, INDNO is "0000000".
Since it is 8h ″ and not equal to 0, the determination is false and the process proceeds to step S118. Then, 5-byte null data (00h) and index number 0000 are set.
1 byte of 0Ch stored in the index table indicated by 0008h and 6 bytes of print data 0
0h, 00h, 00h, 00h, 00h, 0Ch are expanded in the bit map memory 5. Next, step S110.
Then, FADDR is incremented by 3 so that FADDR points to the index number of the second slice. In the next step S111, SCOUNT is reduced by 1 to 47, but since it is not 0, the determination in step S112 is false and the process returns to step S102 for the expansion of the second and subsequent slices.

In the same way, the data in the second and subsequent slices is expanded, but since the INDNO of all data in the second and subsequent slices is larger than N5, the determination in step S103 is true, and in step S113, all 6-byte data is It is easy to understand that it is referred to from within the index table.

"A" is extended to the end as described above.

As described above, according to this embodiment, wasteful null data in the index pattern can be deleted, and an efficient font compression device can be provided.

Further, null data in the index table can be directly stored in the register of the CPU 1, and an excellent effect such as an improvement in processing speed can be expected.

In the above embodiment, the index numbers are assigned in the ascending order with 6 bytes of the sub-matrix as the value, but those skilled in the art can easily conceive that the descending order can be realized in exactly the same manner.

<Description of Second Embodiment> A second embodiment will be described. In the above embodiment, the pattern values of the sub-matrix are assigned in descending order or in ascending order and the upper or lower null data is deleted.

For example, when arranged in ascending order, it is efficient when the upper several bytes of the sub-matrix are consecutively null, but conversely, there is a significant dot only in the upper 1 byte and in the lower 5 bytes. If there is continuous null data, no action is taken.

Therefore, in the second embodiment, the sub-matrix is a so-called sub-matrix, where the upper 5 bytes are null, the upper 4 bytes are null, ..., The lower 1 byte is null, the lower 2 bytes are null ,. The bytes are rearranged so as to be null, and an index table as shown in FIG. 9 is created. Here, each threshold value is set to N1 to N65.

As a result, it is possible to determine how many bytes are null from the upper and lower sides depending on the threshold values, so that the index table can be configured as shown in FIG.

As a result, the operation processing procedure of the CPU 1 when the character pattern is actually generated is as shown in FIGS.

The difference between FIG. 11 and FIG. 7 described above is that
When the value of the variable INDNO is larger than the threshold value N5, the processing step S2 for dealing with the threshold values N61 to N65.
This is the point where 00 is added.

Therefore, the process of step S200 will be described with reference to FIG.

First, in step S201, INDNO is N6.
It is determined whether it is smaller than 1. When the determination is true, the process proceeds to step S112, and when the determination is false, the step S2
In 02, it is determined whether INDNO is smaller than N62.
If the determination is true, the process proceeds to step S207, and if the determination is false, the process proceeds to step S203. Similarly, INDNO is set to N in steps S203, S204, and S205.
It is determined whether it is smaller than 63, N64, N65. If the determination is true, steps S208, S209,
Proceed to S210. If the determination in step S205 is false, the process proceeds to step S211.

Here, steps S201, S202, S
S20 when the determinations of 203, S204, and S205 are true
6, S207, S208, S209, S210, and S
The step S211 when the determination of 205 is false will be described.

Since step S206 is exactly the same as step S113, its explanation is omitted. In step S207, N61 address + (INDNO-N61) * 5 is calculated and stored in IADDR, and then 5 bytes of data and 1 byte of null data from IADDR are stored in bitmap memory 5 as 6 bytes of print data. Similarly, in step S208, N62 address + (INDNO-N62)
* 4, N63 address + (IND
NO-N63) * 3, N64 address + (INDNO-N64) * 2 in step S210, and finally step S210.
In 211, when N65 address + (INDNO-N659 is calculated and stored in IADDR respectively, and when the number of bytes of data stored in the index table is M, I
M-byte data from ADDR and 6-M-byte null data are processed as 6-byte print data.

The process of migration is the same as in the first embodiment, and will be omitted.

In the case of the present embodiment, instead of deleting the null data from the MSB side (or the LSB side) from one direction, it is possible to delete the null data from both directions and further compress the data. Become.

<Description of Third Embodiment> Next, a third embodiment will be described. In the third embodiment, in order to further increase the compression rate, the original pattern before compression is subjected to the exclusive OR (XOR) processing of a certain slice of interest and the immediately preceding slice.

FIG. 13 is a diagram showing this exclusive OR processing. The second slice takes an exclusive OR with the first slice. Similarly, the Nth slice and the N-1th slice are exclusive-ORed (N> = 2). Such a differentiated contour shape is newly regarded as an original drawing, and the same processing as that of the second embodiment (the first embodiment may be possible, but the second embodiment is more advantageous) is performed. To do. By this processing, it is possible to further increase the compression ratio by reducing the total number of different patterns in all character slices, increasing the values of N1 to 5 and decreasing the values of N61 to N65.

Since the configuration and processing of this embodiment are the same as those of the second embodiment, details will be omitted.

In order to reproduce the original pattern, once the outline font of FIG. 13 is expanded, XOR is performed on each slice.
May be used to reproduce the original image, or each slice may be expanded while XORing with the immediately preceding reproduced slice.

Those skilled in the art can easily contemplate the following description.

<Explanation of Fourth Embodiment> In the above first to third embodiments, the case of being adapted to the printing apparatus has been described.
As is clear from the above description, the gist of the present invention relates to the management and generation of character patterns, and is not limited by the output target.

For example, as shown in FIG. 14, it can be applied to ordinary electronic equipment (for example, personal computer). Here, 14 is a display device for displaying characters and symbols, and 15 is a V for expanding the pattern displayed on the display screen.
RAM and 16 are CGROMs. The operation and processing contents are the same as those in the first to third embodiments, and therefore need not be described. Reference numeral 17 is a keyboard.

From the viewpoint of processing speed, in the processing of the third embodiment, the processing for performing the exclusive OR processing to generate the character pattern is added and compared with the first and second embodiments. And it may be a little late. However,
Compared with the case of compressing by run length, the speed difference can be neglected considering that the number of loops used frequently in the processing program is reduced and the logical operation is a basic processing for the CPU.

In any case, since the first to fourth embodiments are realized only by address conversion, it can be easily guessed that the processing can be realized at very high speed.

<Explanation of the Fifth Embodiment> By the way, in general, a character pattern has a huge number of characters, and since the number of character types has become abundant in recent years, its memory capacity is also huge. I need. Therefore, there are proposals to apply compression with run length etc.,
In this case, even if a character having a poor compression ratio, that is, there is no significant difference in the information amount after compression with respect to the information amount of the original character pattern, there is a problem that the decompression process is performed and it takes time.

In view of this, in the present embodiment, not only is it meaningless to apply compression to a character having a poor compression ratio, but it also affects the whole in terms of speed.
This problem is eliminated.

For simplification of explanation, it is assumed that the character pattern size in the fifth embodiment is composed of 48 × 48 dots. Further, an example in which the apparatus configuration is adapted to FIG. 1, that is, an example in which it is adapted to a printing apparatus will be described. However, the RAM 3 has the following BADDR and BN.
The difference is that various variables such as O and BCODE are secured. Further, it is assumed that the character code is also processed as an internal code.

The contents of the CGROM 6 are managed as shown in FIG. As shown in the figure, the CGROM 6 stores a compressed character code table 100 that stores the compressed and stored character codes of all characters, a font data area that stores actual character patterns and compressed character patterns, and It is composed of a font data section 101 composed of a pointer area that stores the storage position in the font data area for each character code.

The top of the compressed character table 100 is shown in FIG.
7, the number of compressed characters registered in the compressed character table 100 is stored in 2 bytes (032 in the figure).
2h), and subsequently, the character codes of the compressed and stored characters are stored in ascending order.

The variable BNO secured in the RAM 2
Is for counting compressed character codes, and B
ADDR is used as a pointer in the compressed character table 100, and BCODE is used to store the compressed character code. In the fifth embodiment, since a character pattern is generated with 48 × 48 dots, one character is 28
It will occur as 8 bytes.

The following is a description with reference to the flowchart of FIG. The program according to the flowchart is naturally stored in the ROM 3.

First, in step S300, the CPU 1 stores the start address of the compression table 100 in BADDR. Next, in step S301, the contents of the address indicated by BADDR are substituted into BNO for 2 bytes (the one enclosed in parentheses in the drawing indicates the stored contents).
That is, the number of compressed characters is stored in the variable BNO.

Next, in step S302, BADDR
Is incremented by "2" and set so as to indicate the first character code. In step S303, BADD
2 bytes (character code) indicated by R are BCOD
Store in E. Then, in step S304, BADD
Increment R by "2" in preparation for the next time.

Next, when the process proceeds to step S305, it is determined whether or not the character code for which the pattern is to be generated matches the character code stored in the variable BCODE.

If it is determined that they match, the process advances to step S310 to extract the pattern corresponding to the character code from the font data section 101, decompress it, and output it.

If it is determined that they do not match,
In step S306, it is determined whether the value represented by the character code to be generated is larger than the value represented by the character code stored in the variable BCODE.
If the result of this determination is "YES", then step S
In step 307, the content of the variable BNO is decremented by "1", and it is determined in step S308 whether it has become "0". That is, it is determined whether the search has been performed up to the end of the compressed character table 100.

When BCN is not "0",
The process returns to step S302 and the above process is repeated.

During the above processing, when the value represented by the character code to be generated becomes smaller than the value represented by the character code stored in the variable BCODE at that time (in the compressed character table, It has already been described that the character codes are arranged in ascending order). Since it is meaningless even if the search processing is further performed, it is determined that the pattern corresponding to the target character code of the generation target is not compressed. Further, even when the BNO has become “0”, it can be determined that it is due to the same reason.

Therefore, in such a case, step S
At 309, it is assumed that the corresponding font data is stored in the non-compressed format, and it is read and expanded in the bitmap memory.

As a result, the compressed character pattern and the uncompressed character pattern can be mixed and stored in the font data unit 101, and a character with a poor compression ratio can be directly processed without being expanded. Since it can be managed by the pattern, it is possible to reduce the decrease in speed when viewed as a whole.

When the CGROM is constructed, an appropriate threshold value is set, and the compression character table 100 and the character font data portion 101 are set based on whether the compression rate is higher than that.
May be added automatically.

For example, when the font data is installed in a rewritable storage device such as a hard disk device by using a floppy disk or the like, the user arbitrarily sets a threshold value and the font data is set on the hard disk according to the set value. Create a file. However, since it is difficult for a general user to input the threshold value by numeral, the threshold value may be set by selecting memory priority, standard, speed priority or the like in three steps.

Further, by positively compressing characters or the like having a low frequency of use (frequency of application), it becomes possible to effectively use valuable memory even for characters that are rarely used. In this case, the less frequently used characters are
For example, the JIS second level may be applicable.

<Explanation of Sixth Embodiment> In the fifth embodiment, it is judged by referring to the compressed character table whether the pattern of the character code to be generated is compressed or not. However, a memory is needed to secure the compressed character table that is the judgment factor, and the number of loops and the like differ depending on the character code that is about to occur, so there is a problem in terms of time.

Therefore, an example for solving this problem will be described as a sixth embodiment.

The principle of the sixth embodiment will be described with reference to FIG. FIG. 18 is a CGR in the sixth embodiment.
The content of OM is shown.

As shown in the figure, each character code stores the entry address of the character as a 3-byte entry address. It is also assumed that the character codes are stored in ascending order, and the corresponding patterns (both compressed patterns and non-acoustic patterns) are also stored in the font table in ascending order.

When extracting the character pattern corresponding to the character code of the character to be generated from the font table, the entry address (start address) of the font is multiplied by 3 to the character code to be generated, It can be easily obtained by using the value as the offset address from the start address of the pointer part,
Whether or not the data starting from the entry address in the obtained font table is compressed cannot be judged by this alone. It is conceivable to store such discrimination data in the first bit in the entry address, but this requires information for that.

Therefore, in the sixth embodiment, attention is paid to the fact that the character pattern has 288 bytes in the case of non-compression. That is, if the pattern for the character code of interest is compressed, the entry address for the character code next to the character code of interest is located at least 288 bytes before that of the character code of interest.

However, since the last character code cannot be determined by this, a dummy pointer is added for one character.

Based on the above principle, the CP of the sixth embodiment
The operation processing procedure of U will be described with reference to the flowchart of FIG. The program corresponding to the flowchart is naturally stored in the ROM 3, and the variables PADDR, FADDR1 and FADDR2 shown below are all secured in the RAM 2.

First, the character code (internal character code) to be generated in step S400 is multiplied by "3",
A pointer PADDR for the character code of interest is obtained by adding the start address of the pointer portion of the CGROM to it.

Next, proceeding to step S401, the pattern entry address for the character code of interest is acquired from FADDR1 from the position indicated by the pointer PADDR.
Then, in step S402, the pattern entry address for the character code next to the focused character code is set to FADDR.
Get 2

Next, in step S403, the difference between the addresses FADDR1 and FADDR2 is calculated, which is "2".
It is determined whether it is 88 ".

If the value is "288", the pattern corresponding to the character code of interest is uncompressed.
In step S404, the font table 28
8 bytes are read, and are considered to be a 48 × 48 dot pattern and are expanded in the bitmap memory 5.

On the other hand, if it is determined that the address difference is not "288", then it is determined that the character pattern of interest is compressed, and in step S405 the data is read from the entry address and subjected to decompression processing. It is expanded in the bitmap memory 5.

As a result, according to the sixth embodiment, the uncompressed character pattern and the compressed character pattern are mixed and stored and managed, and the error occurs at high speed and effectively using the memory. It will be possible.

In the first to sixth embodiments, the font data is stored in the ROM, but it may be RAM or a rewritable nonvolatile storage medium such as a hard disk device. Absent.

Therefore, the present invention is not limited to a single device, but can be applied to a system composed of a plurality of devices and also to the case of supplying a program from the outside.

Furthermore, in each of the above-described embodiments, one character type has been described, but other character types and a plurality of character types can be applied. In order to adapt to a plurality of character types, it can be realized by providing the above-mentioned font table or the like for each character type, and the greater the number of character types, the greater the effect.

[0120]

As described above, according to the present invention, it is possible to generate a pattern of character symbols at a sufficient processing speed while reducing the amount of information as a whole.

According to another invention, it is possible to provide a pattern generating apparatus and method which are advantageous in terms of both generation speed and memory consumption while mixing compressed and uncompressed character / symbol patterns.

Further, according to the further invention, as compared with the above invention, the pattern has a stable high speed, and further, it is possible to generate a pattern by mixing compressed and uncompressed character symbol patterns.

[0123]

[Brief description of drawings]

FIG. 1 is a block configuration diagram of a printing apparatus according to an embodiment.

FIG. 2 is a configuration diagram of a CGROM according to the first embodiment.

FIG. 3 is a diagram showing a bit configuration of a character “A” used in an embodiment.

FIG. 4 is a diagram showing a bit configuration of a character “A” and an index table in the embodiment.

FIG. 5 is a diagram for explaining a concept of constructing an index table in the embodiment.

FIG. 6 is a diagram showing a structure of an index table adopted in the embodiment.

FIG. 7 is a flowchart showing a character pattern generation processing procedure according to the embodiment.

FIG. 8 is a diagram showing a data structure and a storage state of an index number in a CGROM of a character “A” in the embodiment.

FIG. 9 is a diagram for explaining the index table numbering method in the second embodiment.

FIG. 10 is a diagram showing the structure of an index table adopted in the second embodiment.

FIG. 11 is a flowchart showing a character pattern generation processing procedure in the second embodiment.

FIG. 12 is a flowchart showing a character pattern generation processing procedure in the second embodiment.

FIG. 13 is a diagram for explaining the outline of the compression processing of the character pattern in the third embodiment.

FIG. 14 is a block configuration diagram of an apparatus adapted in a fourth embodiment.

FIG. 15 is a diagram showing the contents of a CGROM in the fifth embodiment.

FIG. 16 is a flowchart showing a character pattern generation processing procedure in the fifth embodiment.

FIG. 17 is a diagram showing the contents of a compressed character table in the fifth embodiment.

FIG. 18 is a diagram showing the contents of a CGROM in a sixth embodiment.

FIG. 19 is a flowchart showing a character pattern generation processing procedure in the sixth embodiment.

[Explanation of symbols]

 1, 11 CPU 2, 12 RAM 3, 13 ROM 4 Printer engine 5 Bitmap memory 6, 16 CGROM 7 I / F 14 Display device 15 VRAM 17 Keyboard

─────────────────────────────────────────────────── ─── Continuation of the front page (51) Int.Cl. ⁶ Identification code Internal reference number FI Technical indication H04N 1/411 // H03M 7/30 Z 8842-5J

Claims (9)

[Claims] 1. A character symbol pattern of M × N dots is m ×
Sub-matrix storage means for subdividing into a sub-matrix of n (m≤M, n≤N) and arranging possible patterns of the sub-matrix in a predetermined order and storing the sub-matrix. Index information storage means for storing an index information group for specifying each sub-matrix for forming a corresponding character pattern, and extracting the index information group corresponding to a given character symbol code from the index information storage means. A pattern generating device for generating a character symbol pattern by reading a corresponding sub-matrix from the sub-matrix storage means based on each of the extracted index information groups, wherein the sub-matrix storage means has a sub-matrix pattern. Where significant dots of And, the according sequence corresponding to the location of significant dots, the with the contents of the index information, the pattern generating apparatus characterized by significant pattern length stored is ready to be discriminated. 2. The sub-matrix storage means performs an exclusive OR operation on adjacent sub-matrices forming a character symbol pattern, and stores the sub-matrix after the logical operation. The pattern generator according to item 1. 3. The size of the sub-matrix is 1-bit width, and the sub-matrix storage means has a range of byte units having non-output dots continuously from the upper or lower direction of the pattern of the sub-matrix. The pattern generating device according to claim 1 or 2, wherein the continuous byte portion is excluded from the storage target when it is present. 4. A character symbol pattern of M × N dots is vertically
Alternatively, as a set of horizontal 1-dot rows of subdivided patterns, a predetermined subdivided pattern of each subdivided pattern in each character symbol is specified so that one subdivided pattern can be uniquely identified by an index number. And a second storage means for storing, for each character and symbol code, an index number information group for specifying a subdivided pattern for forming a corresponding character and symbol pattern. A pattern generator that, when a character / symbol code is given, sequentially extracts corresponding subdivision patterns by referring to the index information group corresponding to the character / symbol code, and which generates a character / symbol pattern, The first storage means, when the subdivided pattern is viewed from a predetermined direction, blanks up to the presence of significant dots. It is characterized by storing the subdivided patterns in order according to the byte length in which the remaining significant dots exist, and when a character / symbol code is given, the index information group of the character / symbol code is stored. According to the contents of the individual index information, the judgment means for judging the number and position of significant bytes of the corresponding subdivision pattern, and the subdivision pattern for the corresponding byte length based on the judgment result of the judgment means. And a means for adding a corresponding number of blank bytes to generate a regular subdivided pattern. 5. An M × N dot character / symbol pattern is vertically,
Alternatively, as a set of horizontal 1-dot rows of subdivided patterns, a predetermined subdivided pattern of each subdivided pattern in each character symbol is specified so that one subdivided pattern can be uniquely identified by an index number. In the order of, the index number information group for specifying the subdivision pattern for forming the corresponding character / symbol pattern is stored for each character / symbol code, and when the character / symbol code is given, A pattern generating method for generating a character / symbol pattern by sequentially extracting corresponding subdivision patterns by referring to an index information group corresponding to a character / symbol code, wherein the subdivision pattern is stored in a predetermined direction. When viewed from, the white space up to the existence of significant dots is deleted in bytes, and the remaining significant dots are deleted. The subdivision patterns are stored in the order according to the byte length in which the character code exists, and when a character code is given, the significant subdivision pattern of the corresponding subdivision pattern is determined according to the content of each index information of the index information group of the character code. Judge the number of bytes and their positions, and read the corresponding subdivision pattern with the corresponding byte length based on the result of this judgment, and add a corresponding number of blank bytes to generate a regular subdivision pattern. A method for generating a pattern, which comprises: 6. A storage means for storing a compressed character / symbol pattern and an uncompressed character / symbol pattern in a mixed manner,
A pattern generator for reading out a corresponding compressed character pattern or non-compressed character pattern from the storage means based on a given character symbol code and decompressing and outputting the compressed character pattern. Discrimination information storage means for storing information for discriminating the character / symbol code of a pattern, and determination for determining whether or not a pattern corresponding to a given character / symbol code is compressed by referring to the discrimination information storage means And a decompression unit that decompresses the information read from the storage unit when it is determined that the character / symbol pattern for the target character / symbol code is compressed as a result of the determination by the determination unit. Character pattern generator. 7. A storage unit for storing a compressed character / symbol pattern and an uncompressed character / symbol pattern in a mixed manner,
A pattern generation method for reading out a corresponding compressed character pattern or non-compressed character pattern from the storage means based on a given character / symbol code and decompressing and outputting the compressed character pattern. The discrimination information storing means for discriminating whether or not the character / symbol code has been compressed, and whether the character / symbol pattern corresponding to the given character / symbol code is compressed by referring to the discrimination information storing means. And a decompression unit that decompresses the information read from the storage unit when it is determined that the pattern for the target character symbol code is compressed as a result of the determination process. Character pattern generation method. 8. A pattern storage means for storing a compressed character-symbol pattern and a non-compressed character-symbol pattern in a continuous manner in a mixed manner, which corresponds to the pattern storage means based on a given character-symbol code. A pattern generator for reading out a compressed character pattern or an uncompressed character pattern and expanding the compressed character pattern to output the compressed character pattern, which corresponds to the order of patterns stored in the pattern storage means and corresponds to each character symbol code. When an address storage means for storing a storage destination address of the pattern storage means and a character / symbol code are given, the storage destination addresses of the character / symbol code and the next character / symbol code are given from the address storage means. The address extraction means to be extracted and the difference between the addresses extracted by the extraction means, the given character A pattern generation device, comprising: a determination unit that determines whether or not the pattern corresponding to the number code is compressed. 9. A pattern storage means for storing a compressed character / symbol pattern and a non-compressed character / symbol pattern in a continuous manner in a mixed manner, which corresponds to the given character / symbol code from the pattern storage means. A pattern generation method for reading out a compressed character pattern or an uncompressed character pattern and decompressing and outputting the compressed character pattern, which corresponds to the order of patterns stored in the pattern storage means and corresponds to each character symbol code. An address extraction step of extracting the storage address of each of the given character and symbol code and the subsequent character and symbol code by referring to the address storage means that stores the storage destination address of the pattern storage means, The pattern corresponding to the given character symbol code is compressed due to the difference in the addresses extracted in the extraction process. Pattern generation method characterized by comprising a determination step of determining whether to have.