JPH07336696A - Compressing system and expanding system for two-dimensional image data - Google Patents

Abstract

PURPOSE:To provide a data compressing system and a data expanding system to raise the data compression rate of image data and reduce the quantity of information and besides, compress and expand the data at high speed. CONSTITUTION:A data compressing device to realize the data compressing system is provided with a dictionary buffer 6 which holds the one line preceding data for two-dimensional image data to be inputted successively, a buffer 16 which extracts plural continuous data strings from the inputted signal of a present line and stores them as compressed object partial data string, a scanning and comparing means 7, 15 which detects whether the same data string as the compressed object partial data string exists in the data stored in the dictionary buffer 6 or not, and a code generator 8 which outputs the data of the position and the length of the partial data string on the one line preceding data stored in the dictionary buffer 6 as the data of that partial data string of the present line in the case that the existence of the same data string is detected by the scanning and comparing means.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a data compression system and a decompression system for two-dimensional image data.

[0002]

2. Description of the Related Art Conventional image compression methods include an irreversible data compression method and a reversible data compression method. The discrete cosine transform (DC
Non-reversible data compression methods such as JPEG and MPEG using T) cannot be used because information loss occurs when compressing image data using a color code (call code of color palette). A typical method of the latter reversible data compression method is a method of performing data compression by using run length of information (run length compression), and performing data compression by registering frequently appearing information in a dictionary. It is a method (dictionary compression). The latter method is IE
EE Transactions on Information Theory IT-24, pp.5
Ziv and Lempel's article "Compr.
ession of Individual Sequenes via Variable Rate Co
ding ".

[0003]

Each of the above compression methods has the following problems. The run-length compression is effective for image data that contains a large amount of the same continuous information, but is ineffective for image data that is not so, and the compression effect may not appear at all.

The dictionary compression is effective for image data having a high hit ratio to the dictionary, but is not effective for image data which is not so. Further, since the hit rate depends on the storage capacity for storing the dictionary, if a high hit rate is desired, a large-capacity storage location is required. Furthermore,
Having a large-capacity dictionary increases the number of dictionary lookups,
The compression speed decreases. Therefore, the present invention compensates for the problems of the above-described compression method, increases the data compression rate of image data, reduces the amount of information, and enables high-speed compression, and expands the compressed data at high speed. It is an object of the present invention to provide a decompression method that can be performed.

[0005]

In order to achieve the above object, in the data compression method of the present invention, two scans are sequentially performed.
When there is a partial data string that is the same as the previous line for at least one pixel while referring to the data of the previous line with respect to the three-dimensional image data, the data of the position and length of the partial data string on the previous line is calculated. Output as data of partial data string.

Further, in the data decompression method of the present invention, when the same partial data string as at least one pixel exists in the immediately preceding line, the position and length of the partial data string on the immediately preceding line are treated as overlapping data. In the decompression method of two-dimensional image compressed data in which information is sequentially input, at least the data of the immediately preceding line is held, information on the position and length of the partial data string is extracted from the input compressed data, and based on this information With respect to the input data of the current line, data corresponding to the length of the partial data string is extracted from the position of the partial data string of the held data of the previous line, and is output as decompressed data.

Further, a data compression apparatus for realizing the above-mentioned data compression method is provided with a reference memory means for holding data of one line before for sequentially input two-dimensional image data and an input current line signal. Buffer means for extracting a plurality of continuous data strings and storing them as compression target partial data strings, and scanning comparison for detecting whether or not the same data string as the compression target partial data string exists in the data stored in the reference memory means And the scanning comparison means detect the presence of the same data string, the position and length data of the partial data string on the data one line before stored in the reference memory means is changed to that part of the current line. A code generation means for outputting as data of the data string is provided.

Further, the data decompression device for implementing the above-mentioned data decompression system is provided with a buffer memory means for holding the data of one line before the sequentially inputted two-dimensional image data, and a partial data string from the inputted compressed data. Means for extracting the information on the position and length of the partial data, and based on this information, the partial data from the position of the partial data string of the data of the immediately preceding line held in the buffer memory with respect to the input current line data. Decoding means for extracting data for the length of the column and outputting it as decompressed data is provided.

[0009]

In order to facilitate understanding of the present invention, the principle of the present invention will be described with reference to the drawings. In the present invention, the property that a pixel having image data is similar to a pixel group in the vicinity is used, and in the two-dimensional image data (shown in FIG. 1) that is sequentially scanned, the data of the immediately preceding line is stored as reference data (which is stored). The buffer is referred to as a "dictionary" 1.) and the dictionary 1 of the immediately preceding line is referred to by the subsequence 2 of the line data to be compressed, and the subsequence is as long as possible and the dictionary of the immediately preceding line in the reference. When it matches the partial string of 1, the position 4 of the partial string 3 on the dictionary 1 and the length of the partial string are encoded to perform data compression. At this time, the position 4 of the subsequence 3 in the dictionary 1 is expressed as a relative position in the two-dimensional space from the compression target subsequence 2, and the relative position and the length of the subsequence 3 are encoded. Further, the reference range for the dictionary 1 is limited to a range in which the degree of similarity between the compression target subsequence 2 and the subsequence in the dictionary 1 is high. Furthermore, if the compression target subsequence 2 does not match the subsequence in the dictionary 1, run length compression or the like is applied to the compression target subsequence 2. It is desirable that the above code is not a fixed length code but a variable length code in order to allocate a short code to data with a high probability of occurrence and to increase the compression rate.

According to the present invention, as described above, the capacity of the dictionary is very small because it is sufficient to store only the immediately preceding line, and the dictionary is referred to within a range of high similarity, and the longest possible subsequence is referred to. It has a high compression rate and can process compression and decompression at high speed. A higher compression rate can be obtained by applying run length compression or the like to the first line of the image data or a partial string for which dictionary reference is not possible.

[0011]

Embodiments of the present invention will be described below in detail with reference to FIGS. FIG. 2 is a configuration example of the data compression circuit of the present invention. FIG. 3 is a flow chart of the data compression algorithm of the present invention. In FIG. 2, 5 is a line buffer, 6 is a dictionary buffer for holding data of one line before, 7 is a comparator, 8 is a code generator, 9 is an adder, 10 is a pointer, 11 is a relative position counter, and 12 is A pointer buffer, 13 is a length counter, 14 is a relative position / length buffer, 15 is a selector, and 16 is a subsequence buffer. Further, 17 is an input signal line to the line buffer, 18
Is an input signal line to the dictionary buffer, and 19 is a code output line.

Next, the outline of the operation of the data compression circuit configured as described above will be described. First, in process 20, the pointer 1
0 and the like are initialized, and the sequentially input image data is stored in the line buffer 5 through the line buffer input signal line 17. At this time, the data pushed out from the line buffer 5 through the dictionary buffer input signal line 18 is stored in the dictionary buffer 6. Next, if the line data input to the line buffer 5 in the process 21 is the data of the first line, the process shifts to the process 25 and the data in the line buffer 5 pointed by the pointer 10 is stored in the partial column buffer 16. The pointer 10 is advanced by 1, the data in the line buffer 5 is input to the comparator 7 through the selector 15, and the partial column buffer 1
Compare with data in 6. If they match as a result of comparison, the length counter 13 is incremented, and the data pointed to by the next pointer is input to the comparator 7 through the selector 15 to be compared with the data in the partial column buffer 16 and one pointer is added until they do not match. The comparison with the data in the subsequence buffer 16 is repeated. When it no longer matches, process 2
At 6, the data of the length counter 13 and the data of the subsequence buffer 16 are input to the code generator 8 and the code is output through the code output line 19. In this way, all data on the first line is processed.

If the line data input to the line buffer 5 in the process 21 is the data of the second and subsequent lines, the process 2
Transition to 2 and search for the longest subsequence. Although the search for the longest subsequence is shown as one process 22 in FIG. 3, it is performed in the following procedure. The concept of searching for the longest subsequence will be described with reference to FIG. 4 showing 8 × 8 image data. In this embodiment, a substring to be searched (data of consecutive pixels selected from the data of the current line is defined as follows)
On the other hand, whether or not the same subsequence as the search target subsequence exists on the line one line before is a position -1 back from the start pixel position of the search target subsequence (defined as relative position -1).
It is determined by searching whether or not the same pixel as the first pixel of the search target partial string exists at a position (defined as relative position +1) advanced by +1 from. That is, when the same pixel row exists within the range shifted by one pixel on the left and right one line before, the process 22 is compressed.

Referring to FIG. 4A, (1) relative position -1
For example, the partial column “55” following “5” in the third row and first column
There is 4 ". This partial string "554" is the same data string as the partial string "554" following "5" in the first column of two rows, so it is determined that the same partial string exists at a position shifted by one pixel to the left. (2) As an example of the relative position 0, there is a partial column "34" following "3" in the first row and fourth column. This subsequence “3
Since “4” is the same data string as the partial string “34” that follows “3” in the fourth column of the 0th row, it is determined that the same partial string exists at a position shifted by 0 pixel. (3) As an example of the relative position + 1, there is a partial column "55434" following "5" in the second row and the 0th column. This partial column “55434” is the first row and first column “5”
Since it is the same data string as the partial string "55434" that follows, it is determined that the same partial string exists at the position shifted by one pixel to the right.

In process 22, first, the data of the pointer 10 is stored in the pointer buffer 12, and the relative position counter 1
Initialize 1. Next, the data for one pixel is fetched from the line buffer 5 pointed by the pointer 10 into the partial column buffer 16. Line buffer 5 to partial column buffer 16
Whether or not there is a matching pixel for the pixel at the relative position −1, the pixel at the relative position 0, and the pixel at the relative position +1 stored in the dictionary buffer for the pixel data of the current line captured in If no search is made, the length “0” is written in the relative position / length buffer 14 for each relative position, and the process proceeds to step 23. In FIG. 4A, 1
Since “4” in row 3 column is 0 row 2 column, 0 row 3 column is “2”, and 0 row 4 column is “3”, the relative position / length buffer 14 has a point (1, 3). ), "0" is written as the length data for all the relative positions -1, 0, and +1. If there is a matching pixel, the pointer 10 and the length counter 15 are incremented, and the data of the adjacent pixel is fetched into the partial column buffer 16. At this time, pointer buffer 1
In 2, there is left the start address of the search target subsequence being searched in this search.

The first pixel of the search target subsequence is the relative position -1.
If a match is found with respect to the next pixel, the data of the pixel at the relative position -1 of the data one line before is compared with the pixel fetched into the partial column buffer 16, and the match with the relative position 0 is found. If found, the data of the pixel at the relative position 0 of the data one line before is compared with the pixel fetched in the sub-sequence buffer 16 for the adjacent pixel, and if a match is found at the relative position +1 For the adjacent pixel, the data of the pixel at the relative position +1 of the data one line before is compared with the pixel fetched in the partial column buffer 16. If the respective comparison results indicate a match, the adjacent pixel pointer 10 is further incremented, the data of the adjacent pixel is fetched into the partial column buffer 16, the length counter 15 is incremented, and the process is repeated until there is no match. As a result, the length counter 1
The value counted in 5 is measured as the length L of the partial data string having the same data string in the data one line before. This length information is relative position -1, relative position 0, relative position +1
Are counted for each of the. That is, after the length L is counted for the relative position −1 as described above, the length L
Was stored in the relative position / relative position -1 column of the relative position / length buffer as length information about the relative position -1, and then temporarily stored in the pointer buffer 12 for searching for the relative position 0. The head address of the search target subsequence is returned to the pixel pointer 10, the relative position counter 11 is incremented, and the pixel pointer 10 is incremented until the data at the relative position 0 does not match the data on the right of the start address of the search target subsequence. Compare while incrementing
The length information L is obtained. Then, the same search is performed for the relative position +1.

Considering a partial column having "5" in the 2nd row and 0th column as the leading pixel in FIG. 4A, since this pixel is the beginning of the line, there is no data at the relative position -1 of the previous line, so the length is L becomes 0. As for the relative position 0, “5” exists in the 1st row and 0th column, so the length counter 13 is incremented and the adjacent 2nd row and 1st column data “5” of 2nd row and 0th column “5” is converted into the partial column buffer. It is taken in 16 and compared with "5" in 1 row and 1 column. Since this is also the same, the length counter 13 is incremented and "5" in 2 rows and 1 column
2 adjacent 2 rows and 2 columns of data “4” is the partial column buffer 1
It is taken into 6 and compared with "5" in 1 row and 2 column. Since this is different, the number of matched data "2" by this time is the relative position 0 of the partial column having "5" in the 2nd row and 0th column as the first pixel.
For L = 2.

As for the partial column in which the first pixel is "5" in the 2nd row and 0th column, "5" exists in the 1st row and 1st column and coincides with the leading pixel, so that the adjacent pixel is also compared at the relative position +1. The adjacent data “5” of 2 rows and 1 column of “5” of 2 rows and 0 column is fetched into the partial column buffer 16 and the relative position +
1 is compared with “5” in the 1st row and the 2nd column. Since they coincide with each other, if the pixels on the right side are sequentially fetched and the comparison is continued, there is a disagreement when the comparison of “3” at 2 rows and 5 columns and “1” at 1 row and 6 columns is performed. Therefore, the value of the length counter 13 at this time is "5".
Is the length L = 5 with respect to the relative position 0 of the partial column having "5" in the 2nd row and 0th column as the leading pixel.

As described above, the length L of the partial column having "5" in the second row and the 0th column as the leading pixel is L (relative position -1) =
Three of 0, L (relative position 0) = 2, L (relative position + 1) = 5 will be stored in the relative position / length buffer. Of these, the longest substring whose length L is 5 is selected. In the case of FIG. 4A, as shown in FIG. 4B, the subsequence a (55) indicates the same subsequence at relative position 0, and the subsequence b
(55434) indicates the same partial sequence at relative position +1. Since the subsequence a has a length of 2 and the subsequence b has a length of 5, the subsequence b having high compression efficiency is selected.

That is, the process 24 is entered, and the relative position
The longest data among the data stored in the length buffer 14 and its relative position are input to the code generator 8 and the code is output through the code output line 19. If all the lengths stored in the relative position / length buffer 14 are 0 in process 23, that is, if no matching subsequence is found in the dictionary, the process proceeds to process 25 and run length compression is performed. . The run-length compression is the same as the conventional run-length compression method, and the detailed description thereof will be omitted. The above operation is repeated up to the final line of the image data to perform data compression and encoding.

Next, the data compression process of the 8 × 8 image data shown in FIG. 4 will be described. Each data shall be represented by 4 bits. In the following, for convenience, the coordinates of the image data (column, row), the encoded code is {relative position,
Length} or [data type, length]. That is, the portion enclosed by curly brackets {} is the portion where compression according to the present invention is performed, and the key brackets []
The part surrounded by indicates the part where compression by the run length is performed.

For example, a code code having a relative position of 1 and a length of 3 is [1,3], a code code of data type 5 and a length of 2 is [5,2]. In addition, the coordinates of the data of interest
If (x, y), the dictionary reference range is (x-1, y-
1), (x, y-1), and (x + 1, y-1). First, since there is no dictionary to refer to on the first line, run length compression is performed. Data from image data (0,0) to (3,0) is 2
Since it is the same, the code is [2,4]. Since there is only one 3 in (4, 0), the code is [3, 1]. (5,
Since the data from 0) to (7,0) is the same as 4, the code is [4,3], and the code of the first line is [2,4] [3,1 as shown in the first line of FIG. ] [4, 3].

The processing of the second line handles the first line as a dictionary. Since (0,1) and (0,0) are compared and do not match, the next comparison is made with (0,1) and (1,0), which also does not match, so there is no matching subsequence in the dictionary. Then, run length compression is applied, and (0,1) to (2
Since 1) is 5, the code is [5, 3]. (3,
Since 4 in 1) does not match (2,0), (3,0), (4,0), run length compression is applied and the code is [4
1]. 3 in (4, 1) is (3, 0), (4
0, the same as (4, 0) in (5, 0),
1) to (5,1) and dictionary (4,0) to (5,0)
Match, the code is {0, 2}. (6,1)
Since (7,1) and (7,1) do not match the dictionary data, the codes are [1,1] and [3,1], respectively. 5,
3] [4,1] {0,2} [1,1] [3,1].

The processing of the third line handles the second line as a dictionary. (0,2) matches the dictionary (0,1) at relative position 0 and the dictionary (1,1) at relative position 1, but in the case of relative position 0, the length of the matching substring is (0 , 1) to (1, 1) and 2, but when the relative position is 1, the lengths of the matching substrings of the dictionary are (1, 1) to (5, 1) and 5, and the relative position 1 Since the partial string of the dictionary is longer, the code is {1, 5}, and when the above process is repeated until the final line, the code string of FIG. 5 is obtained for the image data of FIG. Next, the code string of FIG. 5 is assigned to an actual code by using the code of FIG. The code in the case of run-length compression is composed of an identifier + data type + length, as in 61 of FIG. 6. For example, [2,4] is a binary number 000101110.
Becomes The code in the case of dictionary compression is composed of an identifier + relative position + length, as in 62 of FIG.
1,3} is the binary number 11110. However, since the first line has only run length compression, the code identifier is removed.
The result of converting the code string in FIG. 5 into an actual code is shown in FIG. 7. The image data capacity in FIG. 4 is 256 bits, whereas the data capacity in FIG. 7 is 171 bits. About 67% of the original image data using the algorithm
It means that it was compressed to.

A procedure for expanding the code compressed by the above method will be described with reference to FIGS. 8 to 9. FIG. 8 shows a configuration example of the decompression circuit. FIG. 9 is a flowchart of the data decompression algorithm. In FIG. 8, 29 is an input buffer, 30 is an identifier buffer, 31 is a run length decoder, 32 is a dictionary decoder, 33 and 34 are selectors, 35 is a length buffer, 36 is a comparator, 37 is a length counter, and 38 is a length counter. Adder, 39 decompression buffer, 40 pointer, 41 dictionary pointer, 42 dictionary buffer, 43 input signal line, 4
Reference numeral 4 is an output signal line.

First, the compressed data is fetched into the input buffer 29 through the input signal line 43, the first 1 bit is stored in the identifier buffer, and the pointer 40 and the length counter 37 are initialized to 0 in a process 45. If the content of the identifier buffer is 1, the process proceeds to step 46, and the data that follows is dictionary-compressed data, so the dictionary decoder 32
Through, the decoded length information is stored in the length buffer (process 47), the decoded relative position information and the contents of the pointer are input to the adder 38, and the result is stored in the dictionary pointer (process 48). ). The process moves to the process 49, and the data of the dictionary buffer 42 pointed to by the dictionary pointer 41 is set to the pointer 4
The data is stored in the decompression buffer 39 indicated by 0. The dictionary pointer and the pointer are incremented by 1 (processes 50 and 53), the length counter 37 is incremented, and the content of the length buffer 35 is compared with the comparator 36 (process 54). If the contents of the length buffer and the contents of the length counter do not match (process 55), the process transitions to process 49 in process 56, and processes 49, 50, 53, and 54 are sequentially repeated until they match. If they match, the process proceeds to step 45 and the new code is expanded.

If the identifier is 0 in step 46, step 51
And the decoded length is stored in the length buffer 35. Next, the type of data is stored in the decompression buffer 39 pointed to by the pointer 40 (process 52). The pointer is incremented by 1 (process 53), the length counter 37 is incremented, and the content of the length buffer 35 is compared with the comparator 36 (process 54). If the contents of the length buffer and the contents of the length counter do not match (process 55), the process shifts to process 52 in process 56, and processes 52, 53, and 54 are repeated in order until they match. The above process is repeated until the last code. When the data stored in the decompression buffer 39 reaches one line of image data, all the contents of the decompression buffer 39 are copied to the dictionary buffer 42, and the contents of the dictionary buffer, that is, the restored data are output through the output signal line 44. To do.

In the above-described compression embodiment, the longest subsequence existing in the dictionary is searched from the dictionary reference range and coded. However, in addition to this, the longest subsequence is divided into a plurality of subsequences and other subsequences are divided. There may be a case where it is combined with a partial string and compressed, or a case where a partial string that is not the longest is combined and compressed.

In the former case, for example, the partial sequence b of FIG. 4B is divided into two partial sequences c "5543" and partial sequence d "4" of FIG. 4C, and the partial sequence d "4" is obtained. And "3" in 2 rows and 5 columns
Are combined to form a subsequence e “43”. The code of the subsequence c is {1, 4}, and the subsequence e "43" is the same as "43" following the 1st row and the 4th column, so the code is {-1,
2}. Therefore, the code in the second line is {1,4} {-
1,2} [5,1] [4,1] (this code is code a). In the latter case, for example, in the 2nd row and 0th column, the partial column “55” at the relative position 0 is selected, and in the 2nd row and 2nd column, the partial column “434” at the relative position +1 is selected. This gives 2
The code of the line is {0,2} {1,3} {-1,1}
[5, 1] [4, 1] (this code is code b).

Here, FIG. 4 shown in the embodiment of the compression described above.
The code for the second line in (a) has three patterns including the embodiment. The code on the second line in FIG. 5 is code c. When these codes a, b and c are assigned to the actual codes shown in FIG. 6, the codes a and c are 24 bits and the code b is
Is 26 bits, and the efficiency of the codes a and c is good. However, when codes other than those shown in FIG. 6 are assigned to the codes a, b, and c, the result is different, and the code b may be the shortest code. Therefore, it is not always best to search and encode the longest subsequence in the dictionary,
It is preferable to select a combination of subsequences in the dictionary that is the shortest when the actual code is assigned.

Even if the combination method of the partial strings in the dictionary is changed so that the code becomes the shortest as described above, the coding rule (using the head position and length of the same partial string in the previous line) is If it does not change, it does not affect the data decompression method.

[0032]

As described above in detail, according to the present invention, the capacity of the dictionary is very small because it is necessary to store only the immediately preceding line, and the dictionary is referred to within a range of high similarity.
Since the subsequence as long as possible is referred to, the compression rate is high and the compression and decompression can be processed at high speed. A higher compression rate can be obtained by applying run length compression or the like to the first line of the image data or a partial string for which dictionary reference is not possible.

[Brief description of drawings]

FIG. 1 is an explanatory diagram showing two-dimensional image data.

FIG. 2 is a diagram illustrating a configuration example of a data compression circuit.

FIG. 3 is a flowchart showing an operation of data compression.

FIG. 4 is an explanatory diagram showing image data before compression.

FIG. 5 is an explanatory diagram showing image data after compression.

FIG. 6 is a diagram showing actual codes.

FIG. 7 is an explanatory diagram showing compressed image data to which actual codes are assigned.

FIG. 8 is a diagram showing a configuration example of a data expansion circuit.

FIG. 9 is a flowchart showing the operation of data decompression.

[Explanation of symbols]

 1 dictionary 2 compression target partial sequence 3 partial sequence on dictionary 4 relative position 17 line buffer input signal line 18 dictionary buffer input signal line 19 code output signal line 43 input signal line 44 output signal line

─────────────────────────────────────────────────── ─── Continuation of the front page (51) Int.Cl. ⁶ Identification code Internal reference number FI technical display location H04N 1/41 B 1/417

Claims (9)

[Claims] 1. Partial data on the immediately preceding line when there is a partial data sequence that is the same as the immediately preceding line for at least one pixel while referring to the data of the immediately preceding line with respect to sequentially scanned two-dimensional image data. A data compression method characterized in that data of column position and length is output as data of the partial data sequence. 2. Information of the position and length of the partial data string on the immediately preceding line is sequentially input as overlapping data when the same partial data string for at least one pixel as the preceding line exists 2 This is a decompression method for three-dimensional image compressed data, in which at least the data of the immediately preceding line is held, information regarding the position and length of the partial data string is extracted from the input compressed data, and the information is input based on this information. A data decompression method characterized by extracting data corresponding to the length of the partial data string from the position of the partial data string of the data of the immediately preceding line held with respect to the data of the current line and outputting it as decompressed data. . 3. The transmission side sequentially scans 2
When there is a partial data string that is the same as the previous line for at least one pixel while referring to the data of the previous line with respect to the dimensional image data, information about the position and length of the partial data string on the previous line is displayed. Output as partial data string data, hold at least the data of the immediately preceding line on the receiving side, extract information about the position and length of the partial data string from the input compressed data, and input based on this information The data of the length of the partial data string is extracted from the position of the partial data string of the data of the immediately preceding line that has been retained, and is output as decompressed data. Compression / expansion method. 4. The data according to claim 1, wherein the information about the position of the partial data string is represented as a relative position in a two-dimensional space from the compression target partial data string of the current line of the immediately preceding line. Compression method. 5. The data compression method according to claim 4, wherein the reference range of the immediately preceding line is limited to a pixel range whose distance from the compression target partial data string of the current line is predetermined. 6. A reference memory means for holding data of one line before for sequentially input two-dimensional image data, and a plurality of continuous data strings are extracted from a signal of the input current line to be compressed. Buffer means for storing as a data string, scan comparing means for detecting whether or not the same partial data string as the compression target partial data string exists in the data stored in the reference memory means, and the same by the scan comparing means When the presence of the partial data string is detected, the position and length data of the partial data string on the data one line before stored in the reference memory means is used as the data of the partial data string of the current line. A data compression apparatus comprising a code generation means for outputting. 7. The scan comparison according to claim 6, wherein the buffer means sequentially increases the number of bits of data extracted from the signal of the current line when the presence of the same data sequence is detected by the scan comparison means. Repeated until the presence of the same data string is no longer detected by the means, and the code generation means applies the data one line before stored in the reference memory means at the time when the presence of the same data string is no longer detected by the scan comparison means. The data compression apparatus outputs the data of the position and length of the partial data string in the above as the data of the partial data string of the current line. 8. The scan comparing means according to claim 6, wherein the scan comparing means has predetermined pixels from the pixel position of the compression target partial data string of the current line in the data of one line before stored in the reference memory means. A data compression device characterized in that data within a range is extracted and compared. 9. The position and length information of the partial data string on the immediately preceding line is sequentially input as the data of the overlapping part when the same partial data string for at least one pixel as the preceding line exists 2 A decompression device for three-dimensional image compressed data, comprising buffer memory means for holding data of one line before for sequentially input two-dimensional image data, and position and length of the partial data string from the input compressed data. Extracting means for extracting information on the partial data string from the position of the partial data string of the data of the immediately preceding line held in the buffer memory means on the basis of this information. A data decompression device comprising a decoding means for extracting data corresponding to the length and outputting it as decompressed data.