JP2000022961A - Device and method for generating code book used for vector quantization, vector quantizing device, and recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To actualize a code book which is adaptive to various images and has high versatility without increasing the capacity of a memory for storing the code book. SOLUTION: The code of a solid pattern which gradually varies in luminance value in a block is generated and the code of an edge pattern which varies abruptly in luminance value is generated; and those obtained codes are stored in the memory 10. When vector quantization is actually performed, the pattern codes stored in the memory are processed to generate the code of a pattern different from them and the code is used for vector quantization to actualize adaptation to all kinds of images consisting of the solid pattern and edge pattern; and only the basic patterns are stored in the memory 10 to suppress the memory capacity small.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an apparatus and method for creating a codebook used in vector quantization, a vector quantization apparatus, and a recording medium storing a program for performing these processes.

[0002]

2. Description of the Related Art Conventionally, various data compression techniques have been proposed. Among them, a technique called “vector quantization” is well known as one of data compression algorithms that can very easily perform decompression processing of compressed data. This algorithm has been known for a long time in the field of signal processing, especially for data compression of image signals and audio signals,
Or it has been applied to pattern recognition.

In this vector quantization, a pixel pattern (code) of a certain size (for example, a block of 4 × 4 pixels) is used.
Are prepared, and a unique number or the like is given to each of them (this collection is called a “codebook”). Then, for example, blocks of the same size (for example, 4 × 4 pixels) are sequentially extracted from the image data of the two-dimensional array, a pattern most similar to the block is found in the codebook, and the pattern number is assigned to the block. Perform data compression. In vector quantization, a data sequence in one block corresponds to one vector.

On the receiving side or decompressing side of the coded compressed data, the original image can be reproduced simply by extracting the pattern corresponding to the number for each block from the code book. Therefore, on the decompression side, if the code book is received or stored in advance, no special operation is required, and the original image can be reproduced with very simple hardware.

[0005]

In executing the above-described vector quantization, it is necessary to create a code book. Then, due to the characteristics of vector quantization, the quality of a reproduced image to be reproduced is closely related to the quality of a codebook to be used. Therefore, for example, when performing image data compression, in order to obtain a high-quality reproduced image while maintaining a high compression ratio, it is an issue how to create a codebook with good performance. ing.

Heretofore, there have been known several techniques for optimizing a codebook, such as the technique of Kohonen's self-organizing map. In these methods, the codebook is optimized by performing appropriate mathematical processing using a sample image or the like. However, all of the conventional optimization techniques have a problem that the obtained codebook becomes a useful codebook only for data used in the optimization.

That is, for example, a codebook optimized using image data of a certain person's face is the best codebook for the image used for the optimization, but is the best codebook for other images. Is not always the best codebook. Therefore, for example, if data compression is performed using the codebook for image data of another person's face, the image quality of an image reproduced from the compressed data will be reduced.

Further, for images included in the classification of the same person's face as the image used for optimization, even if a relatively good image quality is obtained as a reproduced image, images of different classifications such as scenery and characters are obtained. In contrast, image quality often deteriorates. That is, since the patterns included in the code book are completely different depending on the image, there is a problem that the code book has low versatility.

Therefore, no matter what type of image is compressed, optimization is performed using various sample images in order to obtain good image quality of the reproduced image, and all the codebooks obtained by this are registered. It is possible to keep it. In this way, when actually performing vector quantization, codebooks suitable for images of various classifications such as people, landscapes, and characters are prepared in advance, and a pattern close to the original image is selected from among them. Can be selected.

However, in this case, there is a problem that the number of codes to be prepared in advance becomes enormous, and the capacity of a memory for storing the codes becomes extremely large. When the capacity of the memory increases, the scale of the entire device also increases, and it is difficult to reduce the size. In addition, since the cost also increases, it is not practical to adopt such a method.

SUMMARY OF THE INVENTION The present invention has been made to solve such a problem, and an object of the present invention is to realize a highly versatile codebook capable of handling various images.
The purpose of. A second object of the present invention is to realize a highly versatile code book without increasing the memory capacity for storing the code book.

[0012]

According to the present invention, there is provided an apparatus for creating a codebook used in vector quantization, which comprises a set of vectors which are data strings having at least one data, and which is used in vector quantization. A solid pattern creating means for creating at least one kind of solid pattern code in which a data value gradually changes in a block constituting the vector, and an edge in which a data value rapidly changes in the block. Edge pattern creating means for creating at least one type of pattern code.

In another aspect of the present invention, the storage means for storing the pattern codes created by the solid pattern creation means and the edge pattern creation means, and the storage means for executing the vector quantization. It is characterized in that it is provided with code operation means for performing an operation on each of the stored pattern codes to create a different pattern code.

Further, the method of creating a codebook used in vector quantization according to the present invention is a method of creating a codebook used in vector quantization, which comprises a set of vectors which are data strings having at least one data. In the above, at least one solid pattern code whose data value gradually changes in a block constituting the vector and at least one edge pattern code whose data value changes abruptly in the block are defined in advance. It is created as a pattern and stored in the storage unit, and is different from the basic pattern by performing an operation on each pattern code stored in the storage unit at the time of performing the vector quantization. It is characterized in that a pattern code is created.

According to another aspect of the present invention, in a method for creating a codebook used for vector quantization, which comprises a set of vectors as a data string having at least one data, at least one type of pattern code is used. By creating a basic pattern in advance and storing it in a storage unit, and performing the vector quantization, performing an operation on the at least one type of pattern code stored in the storage unit, It is characterized in that a pattern code different from the basic pattern is created.

Further, the vector quantization apparatus of the present invention blocks a data sequence having at least one or more data into a vector, and extracts a vector extracted from a codebook prepared in advance from a compression target. A vector quantization device for searching for a code vector similar to the above and outputting a code corresponding to the code vector, wherein a solid pattern creating means for creating at least one solid pattern code whose data value gradually changes in the block; Edge pattern creating means for creating at least one type of edge pattern code whose data value changes rapidly in the block; and storage means for storing each pattern code created by the solid pattern creating means and the edge pattern creating means. , When performing the vector quantization, By performing an operation on each of the pattern codes stored in the storage unit, a code operation unit that generates a pattern code different from these, and a pattern code read from the storage unit and the code operation unit that is generated by the code operation unit. Vector quantization means for performing the above-described vector quantization using the pattern code.

In another aspect of the present invention, a data sequence having at least one or more data is divided into blocks to form a vector, and a vector is prepared from a code book prepared in advance.
In a vector quantization device that searches for a code vector similar to a vector extracted from a compression target and outputs a code corresponding to the code vector, a storage unit that stores the code book, and when the vector quantization is performed, By performing an operation on each code stored in the storage means, an operation means for creating a code different from these, and a code read from the storage means and a code created by the operation means And a vector quantization means for performing the above-described vector quantization by utilizing.

Further, a computer-readable recording medium according to the present invention is characterized in that a program for causing a computer to execute the processing procedure of the code book creating method according to claim 15 or 16 is recorded.

According to another aspect of the present invention, a data sequence having at least one or more data is divided into blocks to form a vector, and a vector is prepared from a code book prepared in advance.
A recording medium that records a vector quantization program that searches for a code vector similar to a vector extracted from a compression target and outputs a code corresponding to the code vector,
When performing the above-described vector quantization, an operation is performed on each code stored in the storage unit to generate a code different from these, and a code read from the storage unit is provided. A program for causing a computer to execute a vector quantization step of executing the vector quantization using the code created in the operation step is recorded.

[0020]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a functional block diagram illustrating a configuration example of a codebook creating apparatus according to an embodiment of the present invention. FIG. 2 is a configuration example of a vector quantization apparatus that performs data compression using the created codebook. FIG. 3 is a functional block diagram showing FIGS. 3 and 4 are diagrams showing examples of code vectors (pattern images) to be created.

In general, most of the face image has a pattern in which the pixel value changes smoothly as a whole, and the change is monotonous and the change amount is very small. Also, in a landscape image or the like, when viewed partially, there is a pattern in which the pixel value changes smoothly as a whole like the face image. On the other hand, in characters and the like, the pixel value generally changes rapidly and the amount of change is generally very large. Also, in a landscape image or the like, there is a portion where the pixel value changes abruptly like a character.

As described above, all images belonging to various classifications can be roughly classified into a pattern in which pixel values change smoothly as a whole (hereinafter, referred to as a “solid pattern”), It was found that the pattern was composed of a rapidly changing pattern (hereinafter, referred to as an “edge pattern”). Therefore, in this embodiment,
Focusing on the nature of this image, a code for a solid pattern and a code for an edge pattern are created. By properly combining the codes of these two patterns, it is possible to deal with various images.

As the code of the solid pattern, for example, as shown in FIG. 3, a pattern that changes monotonically in eight directions is created. That is, a pattern in which a pixel value (for example, a luminance value) gradually changes is created starting from any one of the edge portions (upper, lower, left, right sides, and four corners) of a block composed of 4 × 4 pixels. . Here, a code vector in units of 4 × 4 pixels is created as an example, but the present invention is not limited to this size.

In FIG. 3, (a) shows a pattern in which the luminance value gradually increases from the left side of the block as a starting point to the right side in a unit of one vertical column as A → B → C → D. (B) is a pattern in which the luminance value gradually increases toward the left side with one vertical column as one unit starting from the right side of the block, and (c) one horizontal row as one unit starting from the lower side of the block. (D) is a pattern in which the luminance value gradually increases toward the lower side with one horizontal row as one unit starting from the upper side of the block. .

FIG. 4E shows a pattern in which the luminance value gradually increases toward the lower right corner in a unit of one diagonal line starting from the upper left corner of the block, and FIG. A pattern in which the luminance value gradually increases toward the lower left corner with one diagonal column as one unit;
(G) shows one diagonal line starting from the lower left corner of the block.
In the pattern in which the luminance value gradually increases toward the upper right corner as a unit, (h) shows that the luminance value gradually increases toward the upper left corner in one diagonal row starting from the lower right corner of the block. It is a pattern that goes.

Of the eight types of patterns shown in FIG. 3, those which are created and registered in advance prior to actually performing vector quantization are shown in FIGS. 3 (a) to 3 (d).
, And any one of FIGS. 3 (e) to 3 (h) in total. The remaining six patterns
As will be described later, it is created when vector quantization is actually executed. In the following, for convenience of explanation, FIG.
And (e) (hereinafter referred to as “basic pattern”).

Here, a procedure for creating a solid basic pattern will be described with reference to the codebook creating apparatus shown in FIG. 1 and a flowchart shown in FIG. In FIG.
First, in step S1, blocks of, for example, 4 × 4 pixels are divided into some groups. For example, in the case of the basic pattern shown in FIG.
~ D.

When performing this grouping, the user first designates a starting point in the block by using the starting point designating section 1 of FIG. When the pattern of FIG. 3A is registered as a basic pattern, the four pixels on the left side (group A) in the block are designated as starting points. Note that the start point specifying unit 1 is configured by an input device such as a keyboard and a mouse.

The grouping section 2 performs grouping according to where the start point is specified by the start point specifying section 1. For example, when FIGS. 3A and 3B are used as basic patterns, one column in the vertical direction is grouped into one group, and when FIGS. 3C and 3D are used as basic patterns, , One horizontal row is grouped as one group. When the basic patterns shown in FIGS. 3E to 3H are used as a basic pattern, one column in the oblique direction is grouped as one group.

Note that, as described above, FIGS.
If one of the patterns (d) and (e) to (h) is registered as a basic pattern,
The rest are all created by computation. Therefore, for example, the basic pattern may always be fixed to the patterns of FIGS. In this case, the start point designating section 1 is unnecessary.

Next, in step S2, the user uses the increment input unit 3 of FIG. 1 to input at least one increment h of the luminance value at the end point as viewed from the start point in the block. In addition,
The increment input unit 3 is also configured by an input device such as a keyboard and a mouse. This increment h is
Instead of the user inputting, the apparatus may set a predetermined default value.

Next, in step S3, the starting point luminance value setting section 4 in FIG. 1 sets the luminance value of the starting point in the block. Here, when giving the luminance value of the starting point, for example,
The interval between 0 and (the intermediate value of the range that can be taken as a luminance value—the increment h) is divided into n equal parts, and each equally divided value is set as the luminance value of the starting point. Here, the equally divided values are given, but the divided values are not necessarily required to be within the range of the above-mentioned 0 (the intermediate value of the range that can be taken as the luminance value−the increment h). Here, a plurality of brightness values are given by calculation, but the user may arbitrarily input the brightness value of the starting point within his own range within the above range.

After the necessary information such as the increment h and the luminance value of the starting point are set in this way, in the next step S4, the codebook generator 9 of FIG. Based on h, the luminance value of each group is calculated by performing, for example, a linear interpolation operation. As a result, a code of a pattern in which the luminance value gradually increases for each group from the start point to the end point is generated.

In the present embodiment, since the luminance value of the starting point is given by the processing in step S3, all the luminance values belonging to each group in the block are smaller than the intermediate value of the range that can be taken as the luminance value. It will be. In other words, the code of the solid basic pattern generated here is
The image is a darker image in which the luminance value as a whole is smaller than the intermediate value.

In step S2, at least 1
One or more increments h are given, and in step S3, a plurality of start point luminance values are given based on the value of each increment h. Therefore, a plurality of codes of the basic pattern as shown in FIG. 3A are generated with different luminance values. By giving the increment h and the luminance value of the starting point one by one, only one basic pattern may be generated.

The plurality of codes (code vectors) generated as described above are stored in the codebook data memory 10 as a codebook of a solid basic pattern in step S5. Note that, in this example, a pattern in which the luminance value gradually increases from the start point to the end point in the block is generated. Conversely, a pattern in which the luminance value gradually decreases may be generated. .

On the other hand, as a code of a basic pattern relating to an edge, for example, 12 kinds of patterns as shown in FIG. In each of the edge patterns created here, at least one or more of the four pixels constituting the left side in the block has an edge portion. Here, 12 types of basic patterns are shown, but the number is not limited to this.

Here, the procedure for creating a basic pattern of an edge will be described with reference to the code book creating apparatus shown in FIG.
This will be described with reference to the flowchart shown in FIG. 6, first, in step S11, the pattern input unit 5 shown in FIG.
Are used to input some reference patterns to be adopted as edge patterns. Here, for example, the luminance configuration is input as a luminance configuration of an edge pattern with reference to a block on an edge where a difference between black and white clearly appears in the original image.

As described above, some of the original images (FIG. 4)
Are input in the step S12, the quantization unit 6 quantizes the luminance value of each pixel in the blocks constituting those patterns, thereby obtaining the luminance in the block. Express values only with a certain set of values.

Next, in step S13, the minimum luminance value subtracting section 7 subtracts the minimum luminance value in the block from the luminance values of all pixels in the block for each input and quantized pattern. Thus, the luminance value of each pixel in the block is expressed only as an increment (difference value) with respect to the minimum luminance value. Then, in step S14, the brightness value changing unit 8
Creates a pattern in which the luminance value of each pixel in the block is changed in order to have a variation in the registered edge pattern.

For example, the luminance values of all the pixels in the block of the pattern generated by the minimum luminance value subtracting section 7 are equally divided into m, respectively.
By setting each of the equal values as the luminance value of each pixel, the number of patterns is increased by a factor of m. At the end of this processing, the difference between the minimum luminance value (here, set to 0 in step S13) and the maximum luminance value in the block for each generated pattern, that is, the increment h ', is known.

Next, in step S15, the luminance value (minimum luminance value) of the start point in the block is set by the start point luminance value setting unit 4 in FIG. Here, when the luminance value of the starting point is given, for example, a range between 0 (the maximum value of the range that can be taken as the luminance value—the increment h ′) is equally divided by k, and each of the equally divided values is set as the luminance value of the starting point. Set. Note that in this case as well, it is not necessary that the values be equally divided as in step S3 in FIG. Also, the user may arbitrarily input within the above range at his own discretion.

When necessary information such as the luminance value of the starting point is set in this way, in the next step S16, the codebook generating section 9 of FIG. The luminance value of each pixel in the block is calculated based on the luminance value of each pixel of the pattern. As a result, a plurality of edge pattern codes having a sharp change in luminance value are generated. The plurality of codes (code vectors) thus generated are stored in the codebook data memory 10 as a codebook of the basic pattern of the edge in step S17.

Next, the configuration and operation for actually performing vector quantization using the code book of the basic pattern created as described above and stored in the code book data memory 10 will be described. FIG. 2 is a functional block diagram illustrating a schematic configuration of the vector quantization device according to the present embodiment. FIG. 7 is a flowchart showing the operation of the vector quantization apparatus.

First, in step S21 of FIG. 7, the original image input section 21 inputs arbitrary image data to be compressed. In the next step S22, the codebook calculation unit 22 reads the codebook of the basic pattern stored from the codebook data memory 10. Here, all the basic patterns of the solid pattern and the edge pattern are read.

In the next step S23, the codebook calculation unit 22 that has read the basic pattern performs a 90 ° rotation process on the read basic pattern four times to generate a code of a different pattern from the basic pattern. I do. For example, assuming that the patterns of FIGS. 3A and 3E are registered as basic patterns as solid patterns, by this processing, FIGS.
The patterns (f) to (h) are created. Similarly, for the edge patterns, different patterns are created by rotating these from the 12 types of basic patterns shown in FIG. As a result, the number of code patterns is quadrupled.

In the next step S24, the codebook calculating section 22 further performs a process of inverting black and white (a process of turning the luminance value back to an intermediate value) for each pattern obtained in the above step S23, thereby further processing. Create different patterns of code. By performing such rotation processing and black-and-white inversion processing, the code book data memory 10
Even if the number of registered patterns is not so large,
The number of patterns actually used at the time of vector quantization becomes very large, and the possibility that a pattern very similar to the original image exists becomes very high.

By the way, in the case of the solid pattern, as is apparent from FIG. 3, the patterns obtained by performing the rotation processing do not overlap each other. In addition, since the solid basic pattern created in advance is a dark pattern in which the luminance values of all pixels are smaller than the intermediate value, the pattern obtained when the black-and-white inversion process is performed is such that the luminance values of all pixels are smaller than the intermediate value. The result is a large bright pattern. Therefore,
Also in this case, the obtained patterns do not overlap each other.

On the other hand, in the case of an edge pattern, when inputting a reference pattern by referring to the original image in the first stage,
The input is performed assuming that no duplication occurs when the rotation processing or the black-and-white inversion processing is performed. However, this operation is not always easy. Therefore, for example, in the code book creating apparatus shown in FIG. 1, there is provided an operation unit for performing a rotation process and a black-and-white inversion process, comparing the operation result with the original data, and outputting an error when the result is duplicated. Then, such inconvenience can be avoided.

Next, in step S25 of FIG. 7, vector quantization (VQ) is performed based on the original image data input in step S21 and a plurality of code data generated by the codebook calculation unit 22. Execute the operation of That is, first, the similarity calculation unit 23 of FIG. 2 calculates the similarity between the two using the original image data and the code data for each block.

The similarity is determined by inputting vector data consisting of each pixel value in a block extracted from original image data and vector data consisting of each pixel value in a block of a code vector to a certain function. Is quantified. A representative example of this function is a function for calculating a Manhattan distance (absolute difference distance) and a Euclidean distance between two input vector data.

Further, the code determination unit 24 determines, for each block, a code having the largest similarity (the smallest Manhattan distance or the smallest Euclidean distance) from the plurality of code vectors generated by the codebook calculation unit 22. Determine each vector. Then, in step S26, a code corresponding to the determined code vector is applied to the block and output as compressed data.

As described in detail above, according to the present embodiment, noting that all types of images are composed of a combination of a solid pattern and an edge pattern, the code of the solid pattern and the code of the edge pattern are It is created in advance. At this time, as shown in FIGS. 5 and 6, the respective basic patterns are standardized and created by a predetermined processing procedure based on the input reference information.

Therefore, by using the solid pattern code and the edge pattern code created as described above, various data including data whose luminance value changes monotonously and data which changes rapidly can be obtained. When compression is performed, the image quality of an image reproduced from the compressed data can be improved. That is, according to the present embodiment, it is possible to realize a highly versatile code book capable of obtaining high-quality reproduced images for various images.

In the present embodiment, when actually performing vector quantization using the above-described codebook, codes of different variations are generated by rotation processing and black-and-white inversion processing, so that the original image is closer to the original image. The pattern code can be applied, and the quality of the reproduced image can be further improved. Further, in this case, it is not necessary to store these generated codes in the codebook data memory 10 in advance, so that the capacity of the codebook data memory 10 can be reduced.

In the above embodiment, a code book of a basic pattern is created in advance and stored in the code book data memory 10. However, information serving as a reference for generating this basic pattern is used. (E.g., information on the starting point position, starting point luminance value, increment from the starting point to the ending point, etc.) are stored, and codes of various patterns including the basic pattern are created when actual vector quantization is executed. You may do it. In this case, the memory capacity can be further reduced.

In the above embodiment, the rotation processing and the black-and-white inversion processing are performed when the vector quantization is executed.
The quantization may be performed in advance before the execution of the vector quantization and stored in the codebook data memory 10. In this case, the code book data memory 10
Has the advantage of being able to provide a general-purpose codebook. In addition, since the amount of calculation during the execution of vector quantization can be reduced, the processing speed is increased.

In the above-described embodiment, in order to increase the number of code vector patterns that can be used, a plurality of equally divided values are adopted as the starting point luminance value in step S3 of FIG. 5 and step S15 of FIG. ing. On the other hand, if it is desired to keep the capacity of the codebook data memory 10 as small as possible, only one luminance value within the above range may be adopted.

The processing of steps S13 to S16 in FIG. 6 is also processing for increasing the number of available code vector patterns. Therefore, if it is desired to keep the capacity of the codebook data memory 10 as small as possible, these steps may be omitted, and only the process of normalizing the pixel values may be performed in step S12. However, in order to not only reduce the capacity of the codebook data memory 10 but also improve the image quality of the reproduced image as much as possible, it is desirable to perform the processing as in the above-described embodiment.

In the above embodiment, both the rotation process and the black-and-white inversion process are performed, but only one of them may be performed. Furthermore, in the above embodiment, when calculating the similarity by the similarity calculation unit 23, the codebook calculation unit 22 performs the process of rotating and inverting the code vector. Conversely, the similarity may be calculated by rotating and inverting the original image while leaving the code vector as it is.

Further, in the above embodiment, when a solid basic pattern is created, a darker pattern is created as a whole. Conversely, a brighter pattern may be created. .

Each of the functional blocks shown in FIGS. 1 and 2 is, for example, a CPU or an MPU, a ROM and a RAM.
And the like, and the operation may be realized according to a work program stored in a ROM or a RAM, or may be configured as hardware. In this case, in the above example, FIG. 1 and FIG. 2 are separately illustrated, but these configurations may be combined to form a single vector quantization device.

In addition, a work program code for realizing the function of each of the above function blocks is supplied from an external recording medium to a computer so that each of the above function blocks is operated in accordance with the program. Is also good. In this case, as a recording medium for storing such a program, for example, a floppy disk, hard disk, optical disk, magneto-optical disk, CD-RO
M, CD-I, CD-R, CD-RW, DVD, zi
p, a magnetic tape, a nonvolatile memory card, or the like can be used.

[0064]

According to the present invention, as described above, a solid pattern code in which a data value gradually changes in a block,
Since an edge pattern code whose data value changes rapidly in a block is created as a basic pattern, it is possible to deal with any type of image composed of a combination of a solid pattern and an edge pattern. According to another feature of the present invention, the above basic pattern is created and stored in advance, and when performing vector quantization, an operation is performed on each stored pattern code. Creates a code of a pattern different from this basic pattern, so that when performing vector quantization, codes of various patterns are generated by computation, and the code of a pattern closer to the original image is applied. And the quality of the reproduced image can be improved. Also, since only the basic pattern need be stored in the storage means, the memory capacity can be reduced. As described above, according to the present invention, a highly versatile codebook that can support various images can be realized without increasing the memory capacity for storing the codebook.

[Brief description of the drawings]

FIG. 1 is a block diagram illustrating a configuration example of a codebook creating apparatus according to an embodiment of the present invention.

FIG. 2 is a block diagram illustrating a configuration example of a vector quantization device according to an embodiment of the present invention.

FIG. 3 is a diagram showing an example of a solid pattern code to be created.

FIG. 4 is a diagram showing an example of a code of a basic pattern of an edge to be created.

FIG. 5 is a flowchart showing a procedure for creating a solid basic pattern.

FIG. 6 is a flowchart showing a procedure for creating a basic pattern of an edge.

FIG. 7 is a flowchart illustrating a procedure for performing vector quantization.

[Explanation of symbols]

 REFERENCE SIGNS LIST 1 start point designation unit 2 grouping unit 3 increment input unit 4 start point luminance value setting unit 5 pattern input unit 6 quantization unit 7 minimum luminance value subtraction unit 8 luminance value change unit 9 codebook generation unit 10 codebook data memory 21 original image Input unit 22 Codebook calculation unit 23 Similarity calculation unit 24 Code determination unit

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Tadahiro Omi, 1-17-1, Yonegabukuro, Aoba-ku, Sendai-shi, Miyagi 301 F-term (reference) 5B057 CB18 CD03 CG06 CH07 5C059 KK08 MD04 MD09 RC32 UA02 UA38 5C078 AA04 BA62 CA14 CA27 DA00 DA01 DA11 5J064 AA04 BA13 BC01 BC16 BC23 BD03

Claims (21)

[Claims] 1. An apparatus for creating a codebook used for vector quantization, comprising a set of vectors as a data sequence having at least one data, wherein a data value gradually increases in a block constituting the vector. Solid pattern creating means for creating at least one kind of changing solid pattern code; and edge pattern creating means for creating at least one kind of edge pattern code whose data value changes rapidly in the block. An apparatus for creating a codebook used in vector quantization. 2. A storage means for storing each pattern code created by the solid pattern creation means and the edge pattern creation means, and each of the pattern codes stored in the storage means when the vector quantization is executed. 2. The code book creating apparatus according to claim 1, further comprising a code operating unit that creates a pattern code different from the above by performing an operation on the pattern code. 3. The solid pattern creating means creates a pattern code in which a data value gradually changes from an arbitrary side and an arbitrary corner in the block as a starting point toward opposite sides and corners. 3. The apparatus according to claim 1, wherein the codebook is used for vector quantization. 4. The solid pattern creating means creates a pattern code in which all data values in the block are smaller or larger than an intermediate value in a possible range. Any one of Items 1-3
An apparatus for creating a codebook used in the vector quantization described in the section. 5. The vector according to claim 1, wherein said solid pattern creating means creates a plurality of pattern codes having the same degree of gradual change but different data values themselves. Codebook creation device used for quantization. 6. The edge pattern creating means includes: pattern input means for inputting a reference pattern; and quantizing means for expressing the input reference pattern only with a predetermined data value group. 3. The apparatus according to claim 1, wherein the codebook is used for vector quantization. 7. The edge pattern creating means according to claim 1, wherein the edge pattern creating means creates a plurality of pattern codes having the same difference between data values in the block but different data values themselves. Code book creation device used in vector quantization. 8. The edge pattern creating means creates a plurality of pattern codes having the same difference between the data values in the block and different data values themselves in addition to those having the same difference between the data values in the block. An apparatus for creating a codebook used in vector quantization according to claim 7. 9. The method according to claim 9, wherein the code operation means performs at least one of a block rotation process and a data value inversion process on each pattern code stored in the storage device. An apparatus for creating a codebook for use in vector quantization according to claim 2. 10. A method for creating a codebook which is composed of a set of vectors which are data strings having at least one or more data and is used in vector quantization, wherein a data value is gradually increased in a block constituting the vector. At least one type of solid pattern code that changes and at least one type of edge pattern code whose data value rapidly changes in the block are created in advance as basic patterns and stored in a storage unit, and the vector When performing quantization, a pattern code different from the basic pattern is created by performing an operation on each pattern code stored in the storage means. How to create a codebook for use in transformation. 11. A solid pattern code in which a data value gradually changes toward an opposing side from an arbitrary side in the block prior to execution of the vector quantization, and an arbitrary pattern in the block. 11. A solid pattern code in which a data value gradually changes from the corner of the starting point toward the opposite corner is created as the basic pattern and stored in the storage means.
A method for creating a codebook used in vector quantization described in 1. 12. Prior to the execution of the vector quantization, a reference pattern is input, and at least a quantization process for representing the input reference pattern with only a predetermined data value is performed, thereby performing the edge processing. 11. The method according to claim 10, wherein a pattern code is created and stored in the storage unit as the basic pattern. 13. When performing the vector quantization, at least one of a block rotation process and a data value inversion process is performed on each pattern code stored in the storage unit. The method according to claim 10, wherein the codebook is used for vector quantization. 14. A data sequence having at least one or more data is divided into blocks to form a vector, and a code vector similar to a vector extracted from a compression target is searched for from a prepared code book.
A vector quantization device that outputs a code corresponding thereto, a solid pattern creating means for creating at least one kind of solid pattern code whose data value gradually changes in the block, and a data value abruptly in the block. Edge pattern creation means for creating at least one kind of changing edge pattern code; storage means for storing each pattern code created by the solid pattern creation means and the edge pattern creation means; A code calculating means for performing a calculation on each of the pattern codes stored in the storage means to create a different pattern code; and a pattern code and the code read from the storage means. Use the pattern code created by the calculation means Vector quantization apparatus characterized by comprising a vector quantization means for performing the vector quantization Te. 15. A method for creating a codebook used for vector quantization, comprising a set of vectors as a data sequence having at least one or more data, wherein at least one type of pattern code is created in advance as a basic pattern. By performing an operation on the at least one type of pattern code stored in the storage unit when the vector quantization is performed, a pattern different from the basic pattern is stored. A method of creating a codebook used in vector quantization, wherein a code is created. 16. The method according to claim 15, wherein the calculation is at least one of a rotation process and a data value inversion process. 17. A computer-readable recording medium having recorded thereon a program for causing a computer to execute the processing procedure of the code book creating method according to claim 15. 18. A data string having at least one or more data is divided into blocks to form a vector, and a code vector similar to a vector extracted from a compression target is searched for from a code book prepared in advance.
In a vector quantization device that outputs a code corresponding to the codebook, a storage unit that stores the codebook, and when performing the vector quantization, performs an operation on each code stored in the storage unit. Thereby, an operation unit that creates a code different from these, and a vector quantization unit that executes the vector quantization using the code read from the storage unit and the code created by the operation unit. A vector quantization device, comprising: 19. The vector quantization apparatus according to claim 18, wherein the calculation by the calculation means is at least one of a rotation process and a data value inversion process. 20. A data sequence having at least one or more data is divided into blocks to form a vector, and a code vector similar to a vector extracted from a compression target is searched from a prepared code book,
A recording medium on which a vector quantization program for outputting a code corresponding to the code is recorded. By performing an operation on each code stored in the storage means when executing the vector quantization, And causing the computer to execute a vector quantization step of performing the vector quantization using the code read from the storage unit and the code created by the calculation step. A computer-readable recording medium on which a program for recording is recorded. 21. The calculation in the calculation step,
21. The computer-readable recording medium according to claim 20, wherein at least one of a rotation process and a data value inversion process is performed.