and the bitplane representing the second most significant bits is and the bitplane representing the least significant bits is

Transcription

1 1 7. BITPLANE GENERATION The integer wavelet transform (IWT) is transformed into bitplanes before coding. The sign bitplane is generated based on the polarity of elements of the transform. The absolute value of each element of the transform is convered into binary numbers. The bitplanes refer to the binary numbers formed by collecting the coefficients from the same weight (position) of the elements. As an example, suppose that one dimensional transform results in B = {5, 6, 3, 2, 7, 5, 3, 6} The sign bitplane is { }, where a positive number is encoded in 0 and a negative number is encoded in 1. The absolute value of the transform is B = {5, 6, 3, 2, 7, 5, 3, 6}. Converting to binary numbers, we have The bitplane representing the most significant bits is and the bitplane representing the second most significant bits is and the bitplane representing the least significant bits is If there exists strong correlation between neighboring elements of the original signal, most of the values in the transform have small magnitude, resulting in a large number of zeros in the upper bitplanes. In the lower bitplanes, the number of ones and zeros ts to be equal. When the number of zeros far exceed the number of ones in any of the upper bitplanes, the entropy of the bitplane is small and accordingly the number of bits needed to represent the bitplane is small. Most of the savings in bits needed to represent the signal is coming from the upper bitplanes. In the compression with losses, the bitplanes from the bottom can be removed to reduce the number of bits at the expense of quality. As more bitplanes are removed, the quality of the signal after reconstruction degrades more severely

2 CODING Each bitplane can be encoded using fewer bits than the original length if the number of zeros is not equal to the number of ones in a random pattern. If the number of zeros is larger than the number of ones or vice versa, the number of bits can be compressed using any of the following algorithms. Further reduction in bits are possible if correlations between the bitplanes are exploited. The regions where the values of transform are high ts to be clustered. ENTROPY CODING The idea of entropy coding, also known as Huffman s algorithm, is to assign longer codewords for less frequent source letters and shorter codewords for more frequent source letters. When the source letters are exted, the average number of bits needed to represent a source letter approaches the entropy of the source. But the complexity of the encoder and decoder increases as more extensions are made. ELEMENTARY GOLOMB (EG) CODING Elementary Golomb coding resembles run length coding where a runs of zeros are ones are encoded based on the probability of the runs. Let q be the probability of zeros and let 5 1 φ = 2 which is the inverse of the golden ratio. Then the order m of the best elementary Golomb code for a given value of q is the unique positive integer satisfying m m/2 q φ < q The order can be found by log( φ ) m = ceil log( q). The input alphabet of the elementary Golomb code is given by {1, 01, 001, 0001,..., 0 m 1 1, 0 m }. The corresponding code alphabet is 0 m 0 0 p 1 1 followed by ceil(log 2 m) bit representation of p. The elementary Golomb codes for various values of m are shown below: m = 2 Input Code

3 00 0 m = 3 Input Code m = 4 Input Code m = 5 Input Code m = 6 Input Code m = 7 Input Code 17-59

4 m = 8 Input Code m = 9 Input Code m = 10 Input Code

5 Given m, the range of q = prob(0) can be found from q m φ The following table shows range of q for given m: φ i m i i 2 log( φ ) q i 10 m i 17-61

6 m i

7 q i EXAMPLE Suppose that a bitplane with length 50 bits given below is encoded using elementary Golomb coding. Find q, m, compressed code, and reconstructed code. Find the compression ratio. Input data: q = 44/50 = 0.88, m = ceil(log(φ)/log(q)) = 4. The coding table is Input Code

8 The compressed data (code) is given by code: The last 0 represents 00 rather than 0000 because the length is 50. The decoder must know the length of the original data. The reconstructed data is identical to the input data. This is a lossless compression. Since there are 27 bits in the compressed data, 46% fewer bits are needed to represent original input data without loss of information. Thus. the compression ratio is 46%. BINARY ARITHMETIC CODING In binary arithmetic coding, the original range (0,1) is divided into regions for data 0 and 1 for the first bit in proportion to P(0) and P(1). The second data bit further narrows the range within (0,1) where the first two bits belongs. As more input bits are encoded, the range becomes narrower and narrower. The final interval is encoded into binary sequence by converting the lower bound and the upper bound into binary numbers. The code is given by the common part of the two binary numbers plus one for the last bit. If the probability of the input sequence is large, the difference between the upper bound and the lower bound is large and the number of bits common between the binary representation of upper bound and lower bound is small, resulting in smaller number of bits. On the other hand, if the difference between the upper bound and the lower bound is small, the number of bits common between the binary representation of upper bound and lower bound is large, resulting in larger number of bits. EXAMPLE Suppose that P(0) = 0.8, P(1) = 0.2, and input data is The original range (0,1) is divided into (0,0.8) and (0.8,1). Since the first bit is 0, the current range is (0, 0.8). This range is further divided into (0, ) = (0.0.64) representing 00 and ( , 1) = (0.64,1) representing 01. The current range (0,0.64) representing the first 2 bits 00 is further divided into (0, ) = (0, 0.512) representing 000 and (0.512,0.64) representing 001. The current range (0, 0.512) representing 000 is divided into (0, ) = (0,0.4096) representing 0000 and (0.4096,0.512) representing The range (0.4096,0.512) representing 0001 is divided into (0.4096, ( )) = (0.4096, ) representing and ( ,0.512) representing This process is represented by a graph shown below. The lower bound and the upper bound of the final range (0.4096, ) representing is converted to binary numbers by keep multiplying by 2 until the first different binary number as shown below = = = = = =

9 = = = = The first bit that is different is the fourth bit. Pick the larger number and truncate after the fourth bit. The code is The binary value of is V = Value = = 7/16 = which falls between the lower bound and upper bound of the final range (0.4096, ) Decoding The decoding table for the binary arithmetic code is given below. S i i cumprob i S i is the symbol for i, and cumprob i is the cumulative probability for i. 1. L = 0, H = 1, R = H L = 1 (initial condition) (L = Low, H = High, R = Range, V = Value) 17-65

10 V L = = R 1 cumprob 2 < < cumprob 1 i = 2, S 2 = 0, output = 0 Update: L = L + R cumprob 2 = = 0 H = L + R cumprob 1 = = 0.8 R = H L = V L = = R 0. 8 cumprob 2 < < cumprob 1 i = 2, S 2 = 0, output = 0 Update: L = L + R cumprob 2 = = 0 H = L + R cumprob 1 = = 0.64 R = H L = V L = = R cumprob 2 < < cumprob 1 i = 2, S 2 = 0, output = 0 Update: L = L + R cumprob 2 = = 0 H = L + R cumprob 1 = = R = H L = V L = = R cumprob 1 < < cumprob 0 i = 1, S 1 = 1, output = 1 Update: 17-66

11 L = L + R cumprob 1 = = H = L + R cumprob 0 = = R = H L = V L = = R cumprob 2 < < cumprob 1 i = 2, S 2 = 0, output = 0 Since we recovered five data bits, we stop at this point. The recovered data is 00010, which is identical to the original data. As an overhead, the length of the original data must be transmitted along with compressed code. If we continue, this process does not. BINARY ARITHMETIC CODING WITH RENORMALIZATION The binary arithmetic coding discussed above cannot be used for the data with large length. For a data with large length, the upper limit and the lower limit is getting so close together, it is not possible to distinguish them with the fixed length processors. This problem can be avoided if the range is renormalized so that the limits to not converge each other. Also, the binary code is obtained as the coding progresses rather that at the. Encoding d(i) = original data L = 0 H = 1 R = H L q = probability of zero If d(i) = = 0 then L = L (no change) H = L + R*q R = H L else (d(i) = = 1) L = L + R*q H = H (no change) R = H L Renormalization 17-67

12 While R 2^(b 2) do if H < 2^(b 1) then write_one_bit(0) while bits_outstanding > 0 do write_one_bit(1) bits_outstanding = bits_outstanding 1 elseif L 2^(b 1) then write_one_bit(1) while bits_outstanding > 0 do write_one_bit(0) bits_outstanding = bits_outstanding 1 L = L 2^(b 1) H = H 2^(b 1) R = H L else (if) H = 2*H L = 2*L R = H L (while) (L < 2^(b 1) and H > 2^(b 1)) bits_outstanding = bits_outstanding + 1 L = L 2^(b 2) H = H 2^(b 2) R = H L b is the number of bits inside the window. b can be set at 16, 32 or 0. Decoding The length of the original data sequence must be known. Initial condition: L = 0, H = 1, R = H L = 1. V = fractional representation of the first b bits from the encoded data. V L V1 = R If V1 q write_one_bit(0) L = L (no change) H = L + R*q else 17-68

13 write_one_bit(1) L = L + R*q H = H (no change) (if) R = H L Renormalization While R 2^(b 2) do If H 2^(b 1) then /* no action */ elseif L 2^(b 1) then L = L 2^(b 1) H = H 2^(b 1) V = V 2^(b 1) else (L < 2^(b 1) and H > 2^(b 1)) L = L 2^(b 2) H = H 2^(b 2) V = V 2^(b 2) (if) L = 2*L H = 2*H R = H L V = 2*V + read_one_bit( ) (while) EXAMPLE Encode and decode input data using binary arithmetic coding with renormalization. q = P(0) = 0.8. d = [ ] b = 0 Initial Condition: L = 0, H = 1, R = H L = 1 d(0) = 0 d(1) = 0 L = L = 0 H = L + R q = = 0.8 R = H L = 0.8 No renormalization (R > 0.25) 17-69

14 d(2) = 0 d(3) = 1 L = L = 0 H = L + R q = = 0.64 R = H L = 0.64 No renormalization (R > 0.25) L = L = 0 H = L + R q = = R = H L = No renormalization (R > 0.25) L = L + R*q = *0.8 = H = H = R = H L = While R < 0.25 (renormalization) else (L < 0.5 and H > 0.5) bits_outstanding = = 1 L = L 0.25 = H = H 0.25 = R = H L = L = 2*L = H = 2*H = R = H L = (R < 0.25, back to while loop) else (L < 0.5 and H > 0.5) bits_outstanding = = 2 L = L 0.25 = H = H 0.25 = R = H L = L = 2*L = H = 2*H = R = H L = (R > 0.25, exit while loop) d(4) = 0 L = L = H = L + R q = = R = H L =

15 No renormalization (R > 0.25) No more input data bits. Since bits_outstanding = 2 and H < 0.5, run the renormalization to find the encoded bits. If H < 0.5 (True) write_one_bit(0) while bits_outstanding > 0 do write_one_bit(1) bits_outstandinf = bits_outstanding 1 (bits_outstanding = 1) write_one_bit(1) bits_outstandinf = bits_outstanding 1 (bits_outstanding = 0) (exit while loop since bits_outstanding = 0) L = 2*L = H = 2*H = R = H L = The lower limit and the upper limit of (0.2768, ) are converted to binary numbers = = Since the bits are different, we stop and take the one as the last bit of the code. The compressed code is The decimal representation of is V = 7/16 = q=0.8, L = 0, H = 1, R = H L = 1. V1 = (V L)/R = ( )/1 = If V1 q (Yes) write_one_bit(0) (output = 0) L = L = 0 (no change) H = L + R*q = = 0.8 R = H L = 0.8 No renormalization (R > 0.25) V1 = (V L)/R = ( )/0.8 = If V1 q (Yes) write_one_bit(0) (output = 0) L = L = 0 (no change) H = L + R*q = = 0.64 R = H L =

16 No renormalization (R > 0.25) V1 = (V L)/R = ( )/0.64 = If V1 q (Yes) write_one_bit(0) (output = 0) L = L = 0 (no change) H = L + R*q = = R = H L = No renormalization (R > 0.25) V1 = (V L)/R = ( )/0.512 = If V1 q (No) else write_one_bit(1) (output = 1) L = L + R*q = = H = H = (no change) R = H L = Renormalization (R 0.25) While R 0.25 do If H 0.5 (No) elseif L > 0.5 (No) else (L < 0.5 and H > 0.5) (Yes) L = L 0.25 = H = H 0.25 = V = V 0.25 = = (if) L = 2*L = H = 2*H = R = H L = (R 0.25, renormalization again) V = 2*V + read_one_bit( ) = = If H 0.5 (No) elseif L > 0.5 (No) else (L < 0.5 and H > 0.5) (Yes) L = L 0.25 = H = H 0.25 = V = V 0.25 = = (if) L = 2*L = H = 2*H = R = H L = (R > 0.25, No renormalization, exit while loop) 17-72

17 V = 2*V + read_one_bit( ) = = 0.25 (while) V1 = (V L)/R = ( )/ = If V1 q (Yes) write_one_bit(0) (output = 0) L = L = (no change) H = L + R*q = = R = H L = No renormalization (R > 0.25) Since five data bits are recovered, we stop. The reconstructed data is 00010, which is identical to the original data