JP3391822B2 - Outline font file compression method - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for compressing outline font files.

[0002]

2. Description of the Related Art In desktop publishing, personal computers, word processors, digital fax machines, etc., character font data is prepared in the apparatus. Such font data is normally held by a dot pattern method, an outline method, or a combination thereof. The font representation is then converted to a dot pattern for displaying and printing the outline font.

Conventionally, in rasterization for converting an outline font into a dot image, coordinate data of contour points and attribute data relating to hinting of each contour point are given by a font file, and the actual hinting process uses these coordinate data. It was done by the rasterizer using the attribute data.

Here, the hinting process is a process for shaping the outline beautifully, and various methods such as the character generation method described in JP-A-62-182884 have been proposed.

[0005]

By the way, recently, Tru
New formats such as e Type have been proposed.
In this, the font file contains hint information as a program, and the rasterizer executes the hinting process by executing the hint information. As described above, it is necessary to incorporate the hinting processing conventionally performed by the rasterizer into the font file as a program, which causes a problem that the size of the font file becomes very large.

Therefore, the present applicant previously proposed a method of constructing an outline font file whose file size is compressed (Japanese Patent Application No. 4-95008). That is, FIG.
Calls a subroutine f1 (1 ≦ f1 ≦ m) to control the contour point 1 included in the glyph data, and a subroutine f2 (1 ≦ f2 ≦ m) to control the contour point 2
Is a diagram showing how to call a subroutine fn (1 ≦ fn ≦ m) to control the contour point n. The f1, f2, ... Fn shown here do not mean that n subroutines are prepared, but f
1 represents a subroutine to which the point 1 should be passed.

When the above hinting process is realized on a stack machine, the following is done. That is, First, 0, which is the point number to be processed, is stacked at the top of the stack, and the subsequently called subroutine number f0 is stacked. CALL [] interprets the data at the top of the stack as a subroutine number and jumps to it. The called subroutine f0 interprets the data at the top of the stack as the number of the point to be processed and performs a predetermined process (for example, shifting the contour point upward by 1 bit) for that point. . By repeating such processing,
A predetermined hinting process is performed on all points.

The size of the hinting information is 4 bytes for each contour point (that is, the point number and the subroutine number, P because the subroutine number is called after stacking the number and the subroutine number for each contour point on the stack.
USH instruction and CALL instruction) are required. Therefore, for the entire font, 4 × 200 × 8,000 = 6,400,0
00, 6.4 megabytes, and further compression of hinting information has been desired.

An object of the present invention is to provide an outline font file compression method in which the size of hinting information is reduced to reduce the file size.

[0010]

In order to achieve the above object, in the invention according to claim 1, a plurality of glyph data,
Shared data including a group of subroutines common to each glyph for controlling contour points, wherein the glyph data is outline information consisting of consecutively numbered contour points and their coordinate data, and the outline information. Is a method for compressing an outline font file composed of hinting information consisting of a command sequence for controlling the above, wherein the hinting information is used for passing to a first subroutine, a contour line of one glyph. The first subroutine is a sub-routine that includes a sequence of end point numbers and an instruction sequence including the number thereof, and receives the sequence of end point numbers of the contour line and the number thereof to generate the start point and end point numbers of each contour line. It is characterized by that.

According to the second aspect of the present invention, the hinting information includes the end point number of the contour line, the line width column of the vertical and horizontal stems, and the number of the contour lines, which form one glyph, to be passed to the second subroutine. The second sub-routine is composed of a command sequence and receives the end point number of the contour line, the line width column of the vertical and horizontal stems and the number thereof, and generates the start point and end point number of each contour line. I am trying.

According to a third aspect of the present invention, the hinting information comprises an instruction sequence including point numbers of a start point and an end point of each contour line which constitutes one glyph, and is passed to the third subroutine. The third subroutine is characterized by being a subroutine for receiving the point numbers of the starting point and the ending point of each contour line and correcting the position for each point number.

[0013] In the present invention of claim 4, wherein said hinting information consists instruction sequence including to pass to the fourth subroutine, the point number of the end point of each contour lines constituting one glyph, the fourth This subroutine is characterized in that it receives the point number of the end point of each contour line and corrects the position for each point number.

According to a fifth aspect of the present invention, the hinting information is an instruction sequence including the number of points included in each contour line forming one glyph, which is passed to the fifth subroutine. 5 subroutine receives the number of points included in each contour is characterized by a subroutine to perform the position correction for each point number.

[0015]

The outline font file is composed of shared data including n glyph data and a subroutine for controlling contour points. Glyph data consists of outline information and hinting information. The outline information is composed of consecutively numbered contour points and their coordinate data, and the hinting information is composed of a command sequence for controlling the outline information. The hinting information in one embodiment is composed of a sequence of end point numbers of contour lines forming one glyph and a sequence of instructions for passing the number to the subroutine. As a result, the size of hinting information can be compressed as compared with the conventional method.

[0016]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be specifically described below with reference to the drawings. First Embodiment FIG. 1 is a diagram showing the structure of an outline font file of the present embodiment. The file is composed of n glyph data 1 (glyph 1, glyph 2, ... Glyph n) and shared data 2. Has been done.

FIG. 2 is a diagram showing the structure of the glyph data 1, and the glyph data is composed of outline information 11 and hint information 12. And the outline information 11
Is composed of consecutively numbered contour points and their coordinate data, and the hint information 12 is composed of a command sequence for controlling the outline information 11 (for example, a command for shifting point 1 to the right by one dot). Has been done.

FIG. 3 shows a diagram in which the shared data 2 includes a group of subroutines (subroutines 1 to m) for controlling contour points. In this embodiment, these subroutines will be described later. As described above, information about the starting point, the ending point of the contour line, and the widths of the vertical and horizontal stems is given, and the subroutines S0 and S1 for performing the hinting process on the contour line, the column of the end point number of the contour line, and the number thereof are received Subroutine G0 for generating the start point and end point number of each contour line, Subroutine G1 for receiving the sequence of the number of contour points and the number thereof included in the contour line, and generating the start point and end point number of each contour line, contour line Subroutine G2 that receives the end point number and the line width column of the vertical and horizontal stems and their number to generate the start point and end point number of each contour line, the number of contour points included in the contour line, and the vertical and horizontal Receiving the columns and the number of line widths systems out, subroutine G3 that generates the number of start and end points of each contour line, the subroutine L for subroutine calls
0 is provided.

FIG. 4 is a diagram showing an example of a contour line (glyph) which is the object of the hinting process of this embodiment. In this example, for example, the direction of tracing the contour point is the direction in which the black-painted area is viewed on the right side, the outer contour line is clockwise, and the inner contour line is counterclockwise.
The outer contour of this glyph is 15 from point 0 to point 14
The contour line on the inner side is composed of four contour points 15 to 18. The x-axis increases from left to right and the y-axis increases from bottom to top.

FIG. 5 shows a flowchart of the contour line hinting process of this embodiment. This processing receives the numbers of the start and end points of one contour line (further, the line widths of the vertical and horizontal stems), and performs hinting processing for that contour line. It is prepared as a subroutine in the shared data of FIG. There is.

In FIG. 5, first, the width of the vertical stem is held in HW, and the width of the horizontal stem is held in VW (step 1).
01). As a method of obtaining these data, a subroutine that calls this data is passed as an argument (a subroutine that is passed as an argument and performs this hinting processing is called a subroutine S0), or a method that uses a predetermined value (in this case, There is a subroutine for performing the hinting process).

The starting point number (point 0) of the contour line is held in Ps, and the next point number (point 1) is held in Pe (step 102). If Ps and Pe have the same x coordinate, the line segment from Ps to Pe is a vertical line (step 103). The line segment is either the left or right end of the vertical stem (step 110), but if the y coordinate of Ps is larger than that of Pe, it is determined to be the right end, otherwise it is determined to be the left end. On the other hand, a hinting process is performed to set the width of the vertical stem to VW (step 111,
112).

Even when the x-coordinates of Ps and Pe are different and the y-coordinates are the same (step 104), it is determined exactly whether it is the upper end or the lower end of the lateral stem (step 11).
3). Then, a hinting process is performed on these to set the width of the lateral stem to HW (step 114,
115).

If none of them, another hinting process is performed as a diagonal line or a curved line (step 105). Next, if Pe is the end point of the contour line (step 106), the point number pointed to by Pe is held in Ps, and the start point number of the contour line is held in Pe (step 109).

If Pe is not the end point of the contour line but Ps is the end point of the contour line (step 107), the processing of all points is completed, so that the hinting processing is completed. Otherwise, Ps holds the point number pointed to by Pe, and Pe holds the number of the next point (step 1
08). After that, returning to step 103, Ps (point 1),
The same processing is performed for Pe (point 2), and the above processing is repeated for all points.

As a result, it has been shown that it is possible to perform the hinting processing on the contour line if there is information on the starting point and the end point of the contour line and the widths of the vertical and horizontal stems.

Now, it is assumed that the widths of the vertical and horizontal stems formed by the contour lines are predetermined. Therefore, FIG.
5, the values for HW and VW are set automatically (that is, the widths of the vertical and horizontal stems are limited to one type in one glyph), and as described above, the flowchart of FIG. This is the subroutine S1.

In the present embodiment, a subroutine G0 according to the flowchart shown in FIG. 6 is prepared for shared data.
This subroutine G0 receives a sequence of the end point numbers of contour lines forming one glyph and the number thereof, generates start point and end point numbers of each contour line, and sequentially generates the generated start point and end point numbers. This is a subroutine to be passed to S1.

That is, in FIG. 6, first, Ps and N
Is set to 0 (step 201). While N is smaller than the number of contour end points (this number is popped from the stack and stored in advance), the following process is repeated (step 202). In step 203, one data (end point number) is read into Pe (popped from the stack).
The subroutine S1 is called with Ps and Pe as arguments (step 204). After that, Pe + 1 is set to Ps and N + 1 is set to N (step 205), and step 202
Return to.

By using this subroutine G0, for example, the hinting information of FIG. 4 becomes as follows.
That is, PUSH [3] 18 14 2 G0 CALL [] where PUSH [3] is an instruction for stacking the following 4 bytes of data on the stack, and “18” is the end point of the inner contour line in FIG. 4, “14” is the end point number of the outer contour line in FIG. 4, “2” is the number of number strings, and G0 is the subroutine number.

Therefore, the called subroutine G0
Generates Ps = 0 and Pe = 14 in the first process,
It is passed to the subroutine S1 and Ps = 15 (P
e + 1) and Pe = 18 are generated and passed to the subroutine S1.

In general, since the number of contour lines is large, NPUSH [] n + 2 points 0 points 1. ． ． The procedure is point n-1 n G0 CALL []. Here, n + 2 is the number of data to be stacked.

The size of the hinting information is 15 bytes for each glyph since the number of the end point of each contour line, the number of contour lines and the subroutine number are stacked on the stack before the subroutine is called. 10, n itself for notifying the number of points, subroutine number,
The number of NPUSH instructions and the number of stacks (n + 2), CALL instructions), and the total font size is 15 × 8,000 = 120,000, which is 120 kilobytes.

<Second Embodiment> A second embodiment is an embodiment in which the number of contour points included in a contour is passed instead of the end point number of the contour, and FIG. 7 is a flowchart thereof. This is a subroutine G1 that receives a sequence of the number of contour points included in a contour line that constitutes one glyph and the number of contour points, generates a start point and an end point number of each contour line, and passes it to the subroutine S1 in sequence. is there.

Specifically, first, Ps and N are set to 0. While N is smaller than the number of contour points, the following processing is repeated. Read one data into Pn. Pe to Ps +
The end point of the contour line is obtained as Pn-1. The subroutine S1 is called with Ps and Pe as arguments. After that, Ps
Is reset to Pe + 1 and N is reset to N + 1.

By using this subroutine G1, for example, the hinting information of FIG. 4 becomes as follows. That is, PUSH [3] 4 15 2 G1 CALL [] where “4” is the number of contour points of the inner contour line,
"15" is the number of contour points on the outer contour line, and "2"
Is the number of contour points.

However, since the number of contour lines is generally large, it is not the PUSH instruction, as in the above-described embodiment.
The NPUSH instruction will be used. The size of hinting information is also the same as that in the first embodiment.

<Third Embodiment> In the third embodiment, the end point number of the contour line and the line width column of the vertical and horizontal stems constituting one glyph and the number thereof are received, and the start point and end point number of each contour line are generated. Then, it is a subroutine G2 that sequentially passes it to the subroutine S0. FIG. 8 is a flowchart thereof, and shows a subroutine G2 for shared data.
It is prepared as.

Specifically, first, Ps and N are set to 0. While N is smaller than the number of contour points, the following processing is repeated. Read one data into Pe. Then, HW
And data are read into VW respectively. Ps, Pe, HW
Subroutine S0 is called with and VW as arguments. After that, Pe + 1 is reset to Ps and N + 1 is reset to N.
By using this subroutine G2, for example, the hinting information of FIG. 4 becomes as follows. That is, NPUSH [] 8 18 hw vw 14 hw vw 6 G2 CALL [] where G2 is a subroutine number, and “6” is the number of data received by the subroutine number G2 (6 data from pushed vw to 18). Data), “14 hw v
w ”is the end number of the outer contour line and the width h of the vertical stem
w, the width vw of the horizontal stem, and “18 hw vw” are the end point number of the inner contour line, the width hw of the vertical stem, and the width vw of the horizontal stem.

The size of the hinting information according to the present embodiment is, for each contour line, the end point number and the number of contour lines,
Since the line width of vertical and horizontal stems and the subroutine number are stacked on the stack before calling the subroutine, 3 for each glyph
5 bytes (the number of contour lines is 10, the line widths of the vertical and horizontal stems are 10, the number for notifying the number of data, the subroutine number, and the number to be stacked with the NPUSH instruction, CALL
Command), the total font size is 35 × 8,000 = 280,000, which is 280 kilobytes.

<Embodiment 4> Embodiment 4 is an embodiment in which the number of contour points included in a contour line is passed instead of the end point number of the contour line, and FIG. 9 is a flowchart thereof. This is to receive the number of contour points included in a contour line that composes one glyph, the line width column of the vertical and horizontal stems and the number of them, generate the start point and end point numbers of each contour line, and use them for successive subroutines. It is a subroutine G3 to be passed to S0.

Specifically, first, Ps and N are set to 0. While N is smaller than the number of contour points, the following processing is repeated. Read one data into Pn. Pe to Ps +
The end point of the contour line is obtained as Pn-1. Ps, Pe, H
Subroutine S0 is called with W and VW as arguments.
Then, Pe + 1 is reset to Ps and N + 1 is reset to N.

By using this subroutine G3, for example, the hinting information of FIG. 4 becomes as follows. That is, the size of the NPUSH [] 8 4 hw vw 15 hw vw 6 G3 CALL [] hinting information is the same as that in the third embodiment. By using this subroutine, it is possible to deal with the case where the width of the stem partially changes in a glyph having a large number of strokes.

<Embodiment 5> As described above, the conventional hinting process is performed as follows. In practice, the above procedure is wasteful. Therefore, change this as follows.

[0045] Even if the change is made in this way, exactly the same processing is performed.

In this embodiment, this is changed again to obtain the following. That is, Becomes

The size of the hinting information according to the present embodiment is such that, for each contour point, the number and the subroutine number are stacked on the stack before the subroutine is called, so that 3 bytes (point number and subroutine number, CALL instruction) is required. In addition, NPUSH
Since 2 bytes are required for an instruction, (3 × 200 + 2) × 8,000 = 4,816,0 in the entire font.
It will be 00 and will be 4.8 megabytes.

<Embodiment 6> This embodiment is an embodiment in which the repetition of the subroutine call of Embodiment 5 is compressed. The flowchart shown in FIG. 10 is prepared in the shared data by the subroutine L0 that repeats the CALL instruction with the integer as one argument until the number of data on the stack becomes smaller than the argument.

Specifically, first, the argument is stored in N. The number of data on the stack is stored in S. If N is smaller than S, the CALL instruction is executed. By using the subroutine L0 of this embodiment, the conventional hinting processing described above can be changed as follows.

That is,   NPUSH [] 2 × n + 1 n fn: 2 f2 1 f1 0 f0 L 0   CALL [] Becomes

As for the size of the hinting information according to the present embodiment, since the subroutine L0 is called after stacking the number and the subroutine number of each contour point on the stack, 2 bytes for each contour point (point number and subroutine number). Requires. 2 for NPUSH instruction
Byte, 3 bytes are required for CALL instruction,
The total font size is (2 × 200 + 5) × 8,000 = 3,240,000, which is 3.2 megabytes, and can be compressed to half of the conventional method.

The method of performing the hinting process on the contour line has been described. The above-described embodiment has shown an example of passing the sequence of the end point number of the contour line and an example of passing the sequence of the number of contour points included in the contour line, but there are various options as to what is actually passed, The present invention is not limited to the above. Here, what is important is to pass the minimum information for identifying the starting point and the ending point of the contour line.

In the third and fourth embodiments, an example in which both vertical and horizontal stems are passed is shown, but the present invention is not limited to this. For example, if the width of the vertical stem is constant in one glyph, but the width of the horizontal stem differs for each contour line, it is clear that only the width of the horizontal stem needs to be passed. is there. Further, in the subroutine S1 for processing a predetermined line width, the embodiment can be modified so that various subroutines such as S1 ′, S1 ″, ... With different line widths are prepared. However, as is clear from the above description, the information for hinting, which required several megabytes in the conventional method, is only required in hundreds of kilobytes.

The sixth embodiment is an example of the subroutine L0 which takes the boundary condition as one argument, but the present invention is not limited to this and various modifications can be made. For example, one that takes the required number of CALL instructions as an argument, or CA until there is no data on the stack.
It can be changed to one that repeats the LL instruction.

<Embodiment 7> Since the subroutine group included in the shared data can be called from any glyph, the size of the entire font file can be reduced by preparing a subroutine common to each glyph in the shared data. Can be compressed.

FIG. 12 is a flowchart of the subroutine F prepared in the shared data according to the seventh embodiment.
This subroutine F is a hinting routine for performing position correction on the received contour point number according to the point.

That is, when the point number of the contour point currently being processed is P, the subroutine F determines whether the point P is a vertical stem point (step 301), and when it is a vertical stem point, It is determined whether or not it is on the left side of the vertical stem (step 304). If it is on the left side, the position on the left side of the vertical stem is corrected (step 306), and if not, the position on the right side of the vertical stem is corrected (step 305). ).

When the point P is not a vertical stem point, it is determined whether it is a horizontal stem point (step 302). When it is a horizontal stem point, it is determined whether it is above the horizontal stem (step 307). If it is on the upper side, the upper end is corrected (step 309), and if not, the lower end is corrected (step 308). If it is determined in step 302 that the point is not the lateral stem, it is a point on a curved line or a diagonal line, and therefore a diagonal line (curve) is corrected (step 303).

In the outline font file of FIG. 1, hinting information 1 included in the glyph 1 of this embodiment.
Reference numeral 2 is composed of an instruction sequence for passing the starting point and the ending point of each contour included in the glyph to the subroutine F in the shared data 12. Then, the data transfer is performed using the stack.

FIG. 13 is an operation flowchart of the seventh embodiment. First, an operation of stacking the start point and the end point of each contour included in the glyph on the stack is performed (step 401). Then, the starting point number is popped from the stack (step 402) and is substituted for the point P that is currently being processed (step 403). Similarly, the end point number is popped from the stack (step 404) and is substituted into the end point number Pend (step 405).

When the subroutine F is called, the point P is subjected to the above-described position correction processing (step 40).
6). The subroutine F is repeatedly called by the number of points of each contour line, and the position of all the points of the contour line is corrected (steps 406, 407, 408).

After performing the position correction for all the points included in one contour line, the stack is examined (step 40).
9). If the stack is empty, the process has been completed for all contour lines, so the process ends as it is. Otherwise, the same process is performed for the next contour line.

<Embodiment 8> FIG. 14 is an operation flowchart of Embodiment 8. In this embodiment, only the point number of the end point of each contour is stacked on the stack. That is, in the example of the contour line of FIG. 4, the end point number 14 of the first contour line and the end point number 18 of the second contour line are stacked on the stack. However, the point number of the first point of the first contour line is always 0. The position correction is performed sequentially from the point number 0 in exactly the same way as in the seventh embodiment described above.

<Ninth Embodiment> FIG. 15 is an operation flowchart of the ninth embodiment. In this embodiment, the number of points included in each contour line is stacked (in the example of the contour line of FIG. 4, the number of points of the outer contour line is 15 and the number of points of the inner contour line is 4). ). The point number Pend of the end point of the contour line can be obtained from the point number P of the start point and the number of points included in the contour line. However, also in this embodiment, the point number of the first point of the first contour line is always 0. Others are the same as in the case of the above-described seventh embodiment, and therefore description thereof will be omitted.

[0065]

As described above, according to the present invention.
In this case, the following effects can be obtained. (1) Since the minimum information for identifying the start point and the end point of the contour line is passed to the subroutine that performs the hinting process, the size of the hinting information can be significantly reduced compared to the conventional method. it can. (2) Since the minimum information for specifying the starting point and the ending point of the contour line and the information of the stem width are passed to the subroutine that performs the hinting process, the size of the hinting information is significantly larger than that of the conventional method. Can be compressed into. (3) Since the PUSH instructions are executed collectively in advance,
The size of hinting information can be reduced. (4) Since the subroutine for repeating the CALL instruction is used, the hinting information amount can be further compressed without lowering the processing efficiency. (5) Since the information on the point number of each contour line is passed to the subroutine for performing the hinting processing, the size of the hinting information is compressed and the size of the font file can be compressed. (6) Since information about the number of points included in each contour line is passed to the subroutine that performs the hinting process, it is difficult to stack the start point or the end point on the stack because there are too many points forming one glyph. Is effective when

[Brief description of drawings]

FIG. 1 is a diagram showing a configuration of an outline font file of the present invention.

FIG. 2 is a diagram showing a structure of glyph data.

FIG. 3 is a diagram in which shared data includes a subroutine for controlling contour points.

FIG. 4 is a diagram showing an example of a contour line.

FIG. 5 is a flowchart of contour line hinting processing of the present invention.

FIG. 6 is a subroutine for receiving a sequence of end points of contour lines according to the first embodiment.

FIG. 7 is a subroutine for receiving the number of contour points according to the second embodiment.

FIG. 8 is a subroutine for receiving an end point column and a line width of a contour line according to the third embodiment.

FIG. 9 is a subroutine for receiving the number of contour points and the line width according to the fourth embodiment.

FIG. 10 is a subroutine for calling a subroutine according to the sixth embodiment.

FIG. 11 is a diagram called a subroutine for controlling contour points, which has been previously proposed by the applicant.

FIG. 12 is a flowchart of a subroutine F according to the seventh embodiment.

FIG. 13 is an operation flowchart of the seventh embodiment.

FIG. 14 is an operation flowchart of the eighth embodiment.

FIG. 15 is an operation flowchart of the ninth embodiment.

[Explanation of symbols]

1 glyph data 2 shared data 11 Outline information 12 Hinting information

─────────────────────────────────────────────────── ─── Continuation of front page (58) Fields surveyed (Int.Cl. ⁷ , DB name) G09G 5/24

Claims (5)

(57) [Claims] 1. A plurality of glyph data and shared data including a group of subroutines common to each glyph for controlling contour points, wherein the glyph data are contour points sequentially numbered. A method of compressing an outline font file composed of outline information composed of the coordinate data and hinting information composed of a command sequence for controlling the outline information, wherein the hinting information is passed to the first subroutine. Of the contour line that constitutes one glyph and a sequence of commands including the number of contour lines, and the first subroutine receives the sequence of end point numbers of the contour line and the number thereof, A method for compressing an outline font file, which is a subroutine for generating start and end point numbers. 2. The hinting information comprises a sequence of end points of contour lines forming one glyph, a sequence of line widths of vertical and horizontal stems, and an instruction sequence including the number thereof, which is passed to the second subroutine. 2. The second subroutine is a subroutine for receiving the end point number of the contour line, the line width column of the vertical and horizontal stems and the number thereof and generating the start point and end point numbers of each contour line. Outline font file compression method. Wherein said hinting information to pass to the third subroutine consists instruction sequence including a point number of the start point and end point of each contour lines constituting one glyph, the third subroutine the 2. The outline font file compression method according to claim 1, wherein the outline font file compression method is a subroutine for receiving the point numbers of the start point and the end point of each contour line and correcting the position for each point number. Wherein said hinting information to be passed to a fourth subroutine consists instruction sequence including a point number of the end point of each contour lines constituting one glyph, the fourth subroutine said each contour Receive the point number at the end of the line,
The outline font file compression method according to claim 1, wherein the subroutine is a subroutine for performing position correction for each point number. Wherein said hinting information to pass to the fifth subroutine, consists instruction sequence including a number of points included in each contour forming one glyph, the fifth subroutine each 2. The outline font file compression method according to claim 1, which is a subroutine for receiving the number of points included in the contour line and correcting the position for each point number.