JPH0462678B2 - - Google Patents

Description

[Detailed description of the invention] (b) Industrial application fields The present invention relates to a character pattern processing method.

(b) Conventional technology In word processing devices, which have become popular recently, by inputting document data in kana or Roman characters from the keyboard, kanji conversion is performed and it is possible to create documents containing kanji. The created document is displayed on a display or printed on a printing device.

By the way, when displaying or printing characters, each character pattern is stored in advance in a storage device.
The corresponding character pattern is read out from the storage device and displayed or printed. Each character usually consists of a 24 x 24 dot matrix character pattern as shown in FIG.

On the other hand, when creating a document, characters that need to be emphasized such as headings or titles are preferred to be larger than normal characters, so word processors have an enlargement function as shown in Japanese Patent Publication No. 57-51113, for example. For example, the vertical character pattern in Figure 3,
By enlarging each side twice, quadruple-width characters are created as shown in FIG.

However, if you simply double the height and width,
As shown in FIG. 4, there was a problem in that the angularity of the main body was noticeable where it should have been a smooth curve, and the appearance of the printed characters was not good.

(c) Problems to be Solved by the Invention The present invention has been made to solve the above-mentioned problems, and includes a so-called smoothing process that corrects patterns to reduce the angularity of enlarged character patterns using a simple method. This provides a character pattern processing method that can be performed at high speed.

(d) Measures to solve the problem Detect the presence or absence of data for each dot that makes up the enlarged character pattern, and in the case of a dot with no data, check the data in the diagonal direction in the upper right corner around that dot. Based on the result, check the data of four dots or equivalent dots diagonally centering on the dot with no data, and check the data of the checked dot. The control means is configured to write data to a dot position where there is no data if the data satisfies a predetermined condition.

(e) Effect Since the present invention is constructed as described above, when a dot that has no data among the dots constituting the enlarged character pattern, it is possible to check in which direction the dot data should be checked. Based on the results, by checking the data of a total of 4 dots, 2 dots in diagonal directions around that dot, it is determined whether or not to correct that dot, and if correction is to be made, data is written to that dot to correct it. This allows smooth characters without angularity to be displayed and printed.

(f) Examples Embodiments of the present invention will be described below based on the drawings.

Figure 1 shows the configuration of a word processor device.
Reference numeral 1 denotes a main control device which is connected to each device described later by a signal bus 2 and performs overall control by sending and receiving signals.It is composed of a microcomputer and controls various types of devices according to control programs stored in advance in a built-in program memory. control. An input device 3 is connected to the signal bus 2 and inputs various command signals to the main control device 1, and is composed of a keyboard having numeric keys, alphanumeric keys, various function keys, cursor keys, etc. 4 is a dictionary memory in which character pattern data such as kanji, kana characters, alphanumeric characters, etc. is stored based on JIS codes, and each character is stored as 24 x 24 dot pattern data as shown in Figure 3. , the shaded areas are dots where data “1” is written, and the blank areas are dots where data “0” is written.
These data are read out under the control of the main controller 1 and used for display or printing.

Reference numeral 5 denotes a document data memory in which the created document data is stored as a character code. In the case of special characters such as enlarged characters, an attached code is stored together with the character code, and the document data can be written or read by the main controller 1. controlled.

6 is when the main controller 1 performs enlargement processing, etc.
It is a buffer memory that temporarily stores processing data such as calculation data and variable data, and during expansion processing, it is an area that stores character pattern data obtained by expanding the character pattern data read from the dictionary memory 4, and character patterns corrected by smoothing processing. An area for storing data is provided.

Reference numeral 7 denotes a display device on which character data etc. inputted from the input device 3 are displayed, and is composed of a CRT or LCD display, and displays character pattern data read from the dictionary memory 4 or enlarged character pattern data read from the buffer memory 6. Based on the main controller 1
is displayed by controlling the display control circuit 8. Reference numeral 9 denotes a printing device such as a wire dot or thermal transfer type printing device, which performs printing by controlling the printing control circuit 10 by the main control device 1 as in the case of display.

Next, the operation of the present invention having such a configuration will be explained with regard to smoothing processing of enlarged characters.

First, the outline of the smoothing processing procedure will be explained with reference to FIG.

When an enlargement instruction operation is performed on the input device 3 for a desired character among the characters already displayed on the display device, the main control device 1 changes the character code of the desired character stored in the document data memory 5. At the same time, the code for instructing enlargement is memorized, and in step (101), 24 corresponding characters are stored from dictionary memory 4.
Read the character pattern data of ×24 dots,
The data is converted into 48-dot quadruple-width character pattern data and written into the buffer memory 6. As a result, the character pattern shown in FIG. 3, for example, is converted into the character pattern shown in FIG. 4, and is stored in the buffer memory 6. To convert this character pattern, for example, as shown in Figure 5, data for 8 dots is extracted from a 24 x 24 dot character pattern (see Figure 5a).
By sequentially repeating the process of moving the retrieved data one digit to the right and writing the overflowing data two by two to the 16-bit buffer set in the buffer memory 6, the 8-dot data is expanded horizontally by twice. (See Figures 5a-d). Then, by writing the horizontally enlarged 16-dot data twice in the quadruple-width character pattern data area, vertically, as shown in Figure 5e, it is also doubled vertically, and this operation is repeated. A quadruple-width character pattern can be obtained by Note that this method is just an example, and other methods can also be used.

When the quadruple-width character pattern is obtained, the main controller 1 then proceeds to step (102), where it performs a process of determining whether or not to correct each dot that makes up the quadruple-width character pattern.If correction is to be performed, step (102) is performed. At step 104), data ``1'' is written in the dot area, and then the process proceeds to step 105, where all dots are corrected and then terminated. When the correction is completed, the main controller 1 writes the corrected character pattern data into the display memory in the display control circuit 8 and displays it. In this way, the characters instructed to be enlarged by the input device 3 are smoothed and displayed on the display device 7.

Also, when you finish document creation and print while reading the document data stored in the document data memory 5, if the read character code has a code that instructs enlargement, the same procedure as described above is performed. After the processing, the smoothed character pattern data is supplied to the printing memory in the printing control circuit 10 and printing is performed.

Here, the basic principle of smoothing processing according to the present invention will be explained.

First, if the dot shown in Figure 6a is enlarged twice in the vertical and horizontal directions to the four dots shown in Figure 6b, then one of the four dots is ``1'' as shown in Figure 6c. ” and the dots indicated by the numbers “4” are the dots above the diagonal line C and N on the upper right, i.e., “a, a′, b,
b' and 'g, g', h, h', while the dots marked with numbers '2' and '3' are the diagonal line H in the upper left corner, the dots above 'c, c', The data of "d, d'" and "e, e', f, f'" are checked and smoothing processing is performed.

Therefore, for the dot "1", there is data in both dots "a, a'" and either one of "b, b'" has data, or both "b, b'" have data. When the condition is met, data is written to correct the dots, and when the condition is not met, no correction is made. For dot "2", there is data in both "c, c'" and either "d, d'" or there is no data in both "d, d'". For the dot "3", there is data in both dots "e, e'" and either "f, f'" or "f, f". If there is no data for both dots ``g'' and ``h'', correction is performed, and for the dot ``4'', there is data in both dots ``g, g''', and there is data in either ``h, h''. Correction is performed when there is data or when there is no data for both "h, h'".

As mentioned above, the data of dots on a straight line may be checked, or the dots equivalent to the dots on a straight line, that is, the original dots shown in Figure 6a, can be checked as shown in Figure 6b.
Since the dots are enlarged four times, the data of the four dots are the same, so checking the data of any one of these equivalent dots will give the same result. In this application, for the sake of explanation, a case will be explained in which data of dots on a straight line is checked.

Next, based on such smoothing processing, the smoothing processing operation of the character pattern shown in FIG. 4 will be specifically explained.

As shown in Fig. 7, each dot in the enlarged character pattern is numbered horizontally with M (0 to 47) and vertically with N (0 to 47), and each dot on the matrix is numbered. (M, N), and as shown in FIG. 9, the main controller 1 sets both M and N to "0" in step (201), and smoothes from the upper left corner in step (202). Start the correction process. When the processing of points (M, N) is completed, the process proceeds to step (203) (M+1, N).
Points are processed, then in step (204) points (M, N+1) are processed, and further points (M+1, N+1) are processed in step (205).
This results in 4 dots in the upper left corner (0,0) (1,0)
(0,1) (1,1) point will be processed, and at the end of this process, M will be set to 2 in step (206).
Increase and repeat the above process. As a result, the four dots on the right are processed. By repeating this process, the process is performed in the direction of the arrow shown in FIG. 7, and when the process is completed up to the right end, the main controller 1 proceeds to step (208) and starts the process from the left end, which is one step lower. By repeating this process, it is possible to correct all dots in the enlarged character pattern data.

Now, if both M and N are set to "0" when starting the correction process from the point indicated by A in FIG. ,
After setting Y=0, the process proceeds to the first subroutine shown in FIG. In the first subroutine, first, in step (301), data at the (0,0) point is checked, so the process further advances to the third subroutine shown in FIG. In this subroutine, it is determined in step (501) whether or not X and Y are smaller than "0", but since they are currently "0", the process advances to step (502) and determines which position of the data in the character pattern data. Perform the calculation to find out if there is. Since the main controller 1 processes data in units of 8 bits, address numbers (ADRS) are assigned in units of 8 bits as shown in FIG. By calculating the address number "X/8 + Y x 6", since both X and Y are now "0", ADRS becomes "0", and X/
Since the remainder of 8 is also "0", the OFFSET value indicating the position within the 8 bits is also "0". Based on these calculation results, the main controller 1
In step (504), the 8-bit data of address number "0" is read out from the expanded character pattern data area of buffer memory 6, and in step (505), the read data is shifted to the left by the OFFSET value. The OFFSET value is now "0" and no shift is performed. Next, the process proceeds to step (506), where the most significant bit is read and set in variable A. Then the 10th
Returning to the first subroutine in the figure, the process proceeds to step (302) to determine whether the data read earlier is "1" or not, but the data at the point (0,0) has not been written and is "0". There is a step (303) (304)
The process proceeds to step 11, and performs a process of determining whether or not to perform correction.
In step (304), the process proceeds to the third subroutine in FIG. 12 to check the data at point (0, -1), as described above, but in this case, since Y=-1 and smaller than 0, step (503) is executed. Set ADRS=0, read the data of address number "0" in the same way as above, set the most significant bit to variable B, and then
Proceeding to step (305) of the first subroutine in the figure, it is determined whether B is "0" or not. Since B is now at "0", the program returns to the main routine of FIG. 9 and proceeds to step (203). The processing for the (0,0) point is completed by the above processing, but since no correction is performed in this case, no data is written to the (0,0) point. (0,
When the processing of the 0) point is completed, the process advances to step (203) and the processing of the (1, 0) point is performed. The subroutine and the third subroutine shown in FIG. 12 perform the same processing as described above. In this case as well, no correction is made, and by proceeding to step (204), the (0, 1) point is corrected this time. The process then proceeds to step (205), where correction processing for the (1, 1) point is performed in the same way, but since the above four dots do not satisfy the conditions explained in Figure 6, the data is not actually corrected. Not done.

Next, in this way, the check is performed sequentially in units of 4 dots, and the data is now written (6, 4) (7, 4) (6, 5) (7, 5) as shown in Figure 4 B.
The operation of processing points will be explained.

First, in step (202), the process proceeds to the first subroutine shown in FIG. 10 to process the point (6,4), and then in step (301), the process proceeds to the third subroutine in FIG. ) is calculated in step (502), but since X=6 and Y=4, ADRS=
24, OFFSET = 6, and at step (504), the 8-bit data of address number “24” is “00000011”.
Read out. Next, the data read in step (504) is shifted to the left by the OFFSET value "6"("11000000"). Next, in step (506), the most significant bit is checked and set in variable A. The most significant bit has data and is set to A=1. This completes the processing of the third subroutine and returns to step (302) of the first subroutine, where it is determined whether A=1 or not. Since A=1 now, the process proceeds to step (203) of the main routine in FIG. 9 without any correction processing. After that, do the same for the remaining 3
The dots (7, 4), (6, 5), and (7, 5) are processed, but since data has been written to each of these dots, no correction is performed. In other words, no correction is performed on the dots for which it is detected that data has been written, and the process proceeds to check the next dot.

In this way, the processing progresses sequentially, and is shown enlarged in Fig. 4 (c) and Fig. 14 (30, 4) (31, 4)
The correction processing operation for the points (30, 5) and (31, 5) will be explained.

First, regarding the point (30, 4), ADRS and OFFSET are obtained in the same manner as described above using the first subroutine in Figure 10 and the third subroutine in Figure 12, but since X = 30 and Y = 4, ADRS =27,
OFFSET=6, address number “27” (M=
The 8-bit data “11111100” from 24 to 31) is read out and shifted to the left by the OFFSET value “6” (“00000000”), so the most significant bit becomes “0” and A=0 is set. So step (302)
The process then proceeds to step (303) and checks the point (31, 3), but since the data at this point is also "0", B=0, and in the end no correction is made for the dot at the (30, 4) point. Not possible. Similarly, the processing operation is performed for (31, 4) and (31, 5), but since the conditions for correction are not satisfied, no correction is performed for the dots at these points either.

However, since the point (30, 5) satisfies the conditions for correction, the correction operation will be explained in detail.

Since the check of the point (30, 5) is performed in step (204) of the main routine of FIG. 9, the processing operations are performed by the second subroutine of FIG. 11 and the third subroutine of FIG. 12. Now X=
30, Y=5, so the calculation result at step (502) is ADRS=33, OFFSET=6, so
At step (504), enter address number “33” (M24~
31) data “11111100” is read out,
After being shifted to the left by the OFFSET value "6", the most significant bit is checked and set in variable A to "00000000". Since there is no data in the most significant bit, A=0 is set. Therefore, the first subroutine goes from step (402) to step (403) and checks the data at point (29, 4) diagonally above and to the left of point (30, 5). In the third subroutine, the point (29, 4) is checked in the same manner as described above, but data has now been written to this point and B=1 is set. Next, since B=1, the program proceeds to step (406) and checks the lower right dot (31, 6). Data is also written to this dot, C=
Since it is set to 1, the process advances from step (408) to step (409) and the data at point (28, 3) is checked. There is no data at this point and D=0 is set. Subsequently, in step (412), data at point (32, 6) is checked, but data has been written at this point and E=1 is set.

If you try to correct it in this way, you can check a total of 4 dots of data, 2 dots diagonally around the dot, and when you finish checking the 4 dots of data, both D and E are checked in step (413). Checks whether it is 1 or not, but since both are not 1, proceed to step (414) (30, 5)
The process of writing correction data to the point is performed.

In this process, as shown in FIG. 13, in step (601), calculations are performed to obtain ADRS and OFFSET values. Now X=30, Y=5 and ADRS=33,
OFFSET=6, and then in step (602), read out the 8-bit specific value data "10000000" previously set in the program memory of the main controller 1, and shift it to the right by the OFFSET value "6" found earlier. (see Figures 15a and b). Next, in step (603), the data "11111100" at address number "33" of the enlarged character pattern is read out, and in step (604), a logical conversation is made between the data read out and the data "00000010" shifted earlier, and the data "11111110" is read out. (see Figure 15c, d). Then, by writing the obtained data to the address number "33" position of the area where the corrected character pattern data is stored, the data is written to the point (30, 5) that was blank when expanded. It will be.

Thereafter, by repeating the same process, enlarged characters with less angularity and smooth curves can be obtained as shown in FIG. Note that the correction is not performed on the curved portions, as shown by D, E, H, G, CH, and R in FIG. 4, which should originally be at right angles. Further, although the embodiment deals with the character "R", the smoothing process can be similarly performed on other characters, kanji, etc.

(g) Effects of the invention As mentioned above, the character pattern processing method of the present invention has the following effects:
Correction is performed by checking the data of diagonal dots centered around the dot to be corrected, and by simple data processing, the angularity of enlarged characters is reduced and enlarged characters with smooth curves can be obtained. This has the effect of improving the appearance of printed documents.

[Brief explanation of the drawing]

Fig. 1 is a block diagram showing the configuration of a word processor device embodying the present invention, Fig. 2 is a flowchart showing an overview of the smoothing processing means of the invention, and Fig. 3 is a schematic diagram showing character pattern data in a dictionary memory. 4 is a schematic diagram showing the enlarged character pattern data of FIG. 3, FIG. 5 is a schematic diagram showing the procedure for enlarging character pattern data, and FIG. 6 is a schematic diagram showing the principle of smoothing processing according to the present invention. Fig. 7 is a schematic diagram showing the enlarged character pattern, Fig. 8 is a schematic diagram showing the storage state of the enlarged character pattern data, Figs. 9, 10, 11, 12, and 13.
The figure is a flowchart showing the operating state of the present invention, Fig. 14 is a schematic diagram showing an enlarged part of an enlarged character pattern, Fig. 15 is a schematic diagram explaining the operating state of the present invention, and Fig. 16 is a smoothing diagram. FIG. 3 is a schematic diagram showing processed enlarged character pattern data. 1... Main control device, 3... Input device, 4... Dictionary memory, 5... Document data memory, 6... Buffer memory, 7... Display device, 9... Printing device.

Claims (1)

[Claims] 1 Detect the presence or absence of data for each dot that makes up the enlarged character pattern, and if it is a blank dot with no data, check the data in the diagonal direction in the upper right corner or check the data in the diagonal direction in the upper left corner around that dot. Based on the result, check the data of four dots diagonally around the dot with no data or equivalent dots, and if the data of the checked dots meets the predetermined conditions. A character pattern processing method characterized by writing data into blank dot positions where there is no data.