Recursive Merge-Filter Algorithm For Computing Discrete Wavelet Transform.pdf
Transcript of Recursive Merge-Filter Algorithm For Computing Discrete Wavelet Transform.pdf
Recursive Merge-Filter Algorithm for Computing the Discrete Wavelet Transform
Kunal Mukherjee and Amar Mukherjee
Abstract We present a new wavelet transform algorithm with a data flow that can fully exploit the
locality property of wavelets. This leads to highly optimized fine grained wavelet coding algo-
rithms, in terms of pipelining performance, flexible data granularity and reliability of transmis-
sion. It can be used by all wavelet coding methods, and has been demonstrated to improve the
performance of the most successful ones. We propose a new bottom-up Embedded Zerotree
Wavelet (EZW) image coding algorithm, and demonstrate a 5-10% speedup over EZW, by means
of close coupling between the new wavelet transform algorithm and the EZW encoding. The
Recursive Merge Filter (RMF) operator introduced in this paper reduces the complexity of creat-
ing larger DWTs of size 2N, from smaller ones of size N, by O(logN). Because this is a frequent
operation in the training process of the wavelet based hierarchical vector quantization (W-HVQ)
method, the result is a significant speedup overall. The RMF algorithm facilitates new fine
grained wavelet codecs, based on EZW encoding of sub-images using our new bottom-up algo-
rithm - this can give rise to future standards along the lines of “wavelet JPEG” and “wavelet
MPEG”.
Keywords: recursive merge filter, wavelet transform, hierarchical vector quantization,
zero tree
1
1.0 Introduction
In current wavelet-based codecs (e.g. [1], [3], [8]) the discrete wavelet transform (DWT)
is treated as a “black box” which cannot start generating the code until the entire image has been
transformed. This gives rise to several limitations, such as:
• performance - the computations in these codecs cannot be pipelined until after the entire trans-
form is computed;
• functionality - it is impossible to generate code at the sub-image level, i.e. fine-grained coding
is not possible; and
• reliability - monolithic code, i.e code for the entire image is more susceptible to channel errors
than fine grained code at the sub-image level, e.g. DCT-based codecs like JPEG and MPEG.
The contribution of this paper is a new wavelet transform algorithm developed specifi-
cally for wavelet-based image and video coding, called the Recursive Merge Filter (RMF) algo-
rithm. The data flow of this algorithm exploits the “locality” property of wavelets (e.g. see [7]) to
ensure that intermediate results can be used in the sense of complete DWTs of sub-images of the
input image. Stronger coupling and pipelining between the transform and the coding stages is
made possible because the wavelet transform of the entire image is constructed in a bottom-up
fashion, by merging smaller DWTs into larger ones. Thus, encoding algorithms, multi-resolution
compression, browsing applications etc. can now efficiently access and use the intermediate
stages of the transform.
The data flow of the RMF wavelet transform algorithm exploits the property of spatial
coherence (i.e. intermediate sub-arrays of DWT coefficients occupy the same positions as the
original data). This property leads to a speedup of existing algorithms like EZW [3] and SPIHT
[8], and also gives rise to new wavelet coding algorithms with flexible data granularity. We also
2
introduce the property of constant time “DWT growing”, or combining smaller DWTs into larger
ones. This is shown to result in significant speedup of certain compression algorithms like wave-
let based hierarchical vector quantization (W-HVQ) [2].
The organization of this paper is as follows. In Section 2 we will introduce the Fast Wave-
let Transform (FWT) paradigm for computing the DWT, and the limitations that it imposes on
image coding. In Section 3, we give a formal, recursive notation to describe the RMF operator,
and describe the DWT algorithm in terms of this operator. Next we prove correctness and algo-
rithmic efficiency by showing that the RMF and FWT algorithms are equivalent both in terms of
complexity and input/output behavior. We then proceed to give other properties of the RMF, and
generalize the algorithm to 2-D (two dimensions) and higher dimensions. We also generalize it to
work with arbitrary separable wavelet filters [7], and discuss the broader implications of the RMF
data flow on wavelet image coding.
In Section 4 we present the impact of the RMF paradigm in the application area of image
compression. We highlight the increased efficiency that RMF brings to the W-HVQ training pro-
cedure [1], [2], the tight coupling that is now possible between the DWT computing and the EZW
code generation processes, and the creation of new wavelet-based block codecs based on EZW-
coded wavelet transforms instead of Huffman-coded DCT, e.g. JPEG, MPEG [16].
In Section 5 we give experimental results, and close in Section 6 with a discussion of
future work and open research problems in this domain.
2.0 Fast Wavelet Transform Algorithm
The DWT can be described as a multi-resolution decomposition of a sequence (see [5]).
The DWT can be formally described using the Pyramid Algorithm (PA) notation (see [11]) as:
3
(1)
(2)
The PA takes a sequence (or signal), x(n), of length N as input, and generates a sequence
of length N as output. The output has N/2 values at the highest resolution, N/4 values at the next
resolution, and so on. Let N=2J, and let the number of frequency bands, or resolutions be J, i.e. we
are considering J=logN such bands or octaves, and the frequency index, j, varies in the range: 1..
J, corresponding to the range of frequency resolutions: 21, 22,..., 2J. WL and WH stand for the low-
pass and high-pass coefficient arrays respectively; n = 1,2,..., 2J-j; WL(0, n) = x(n) (i.e. the initial
array of data to be transformed); h(m) and g(m) are the quadrature mirror filters (QMFs) derived
from the wavelet; and L is the length of h and g (also called the number of taps of these filters).
The final output of the DWT will eventually be contained in WH, the first row containing N/2 out-
puts, the second row containing N/4 outputs, and so on.
2.1 Data flow of the Fast Wavelet Transform
In the Fast Wavelet Transform (FWT), the DWT computation proceeds through a succes-
sion of (filter, permute) operations, halving the effective vector (and filter) size after each such
operation, and permuting the newly computed “detail” coefficients to the bottom half of the old
WL j n,( ) WL j 1 2n m–,–( )h m( )
m 0=
L 1–
∑=
WH j n,( ) WL j 1 2n m–,–( )g m( )
m 0=
L 1–
∑=
4
vector. This is shown in Figure 1. In 2-D, the (filter, permute) steps are performed alternatingly
along rows and along columns.
FIGURE 1. Structure of DWT computation
The end result of the transform is organized into the low to high frequency bands, with the
highest frequency band of coefficients occurring at the end (or bottom-half) of the vector, if the
(permute, filter) regimen is followed. Using the example of Figure 1, the end result is WL(3, 1:1)
. WH(3, 1:1) . WH(2, 1:2) . WH(1, 1:4) - a clear organization of the coefficients from the highest
to the lowest octave or frequency band (i.e. 3 to 1).
In addition to the disadvantages of performance, functionality and reliability imposed by
this data flow of the FWT on wavelet coding algorithms (see Section 1), the FWT also has the fol-
lowing disadvantages: 1) Permuting the detail (i.e. high-pass) coefficients becomes a routing
problem and adds to the latency of a linear or mesh array of processors, or a systolic VLSI pipe-
line; 2) The data movement in successive “permute” steps is not load balanced, i.e. as many as
N/2 coefficients have to be moved in the first step, N/4 in the second step, and only one in the last
permute step (e.g. see Figure 1); and 3) There is loss of spatial coherence between the coefficients
after each (filter, permute) step and the original data of the input array x(n).
y1
y2
filtery3
y4
y5
y6
y7
y8
permute
s1
d1
s2
d2
s3
d3
s4
d4
s1
s2
s3
s4
d1
d2
d3
d4
filterS1
D1
S2
D2
d1
d2
d3
d4
permute
S1
S2
D1
D2
d1
d2
d3
d4
S1
D1
D1
D2
d1
d2
d3
d4
filter
5
We will explain spatial coherence with reference to Figure 1. After the first filter step, the
coefficients (s1, d1) comprise the complete DWT of the sub-array (x1, x2). Similarly, (s2, d2) cor-
respond to the DWT of the sub-array (x3, x4), and so on. At this point, the array contains four
complete DWTs of sub-arrays of length two, and these DWTs occupy the same positions of the
array as the original sub-arrays, e.g. (s1, d1) occupy the same positions as (x1, x2), and so on. We
call this the spatial coherence property. In Figure 1, it is easy to see that the next operation, i.e. the
“permute” step shuffles the smooth and difference coefficients, thus destroying the spatial coher-
ence. As we shall shown in future sections, spatial coherence can be a very useful property, if a
wavelet coding algorithm can use the intermediate results of the transform, by interpreting them
as complete DWTs of sub-arrays of the original array.
3.0 The Recursive Merge Filter Algorithm
In this section we will describe the Recursive Merge Filter (RMF) algorithm to compute
the DWT, prove correctness, generalize it to work with arbitrary separable wavelet filters and to
higher dimensions. We also discuss the implications of this algorithm on image compression. The
RMF algorithm computes the DWT of an array of length N in a bottom-up fashion, by succes-
sively “merging” two smaller DWTs (four in 2-D), and applying the wavelet filter to only the
“smooth” or DC coefficients.
6
3.1 Algorithm Description
RMF Operator.
We will first formally define as our primitive, the RMF operator, in terms of the array
indices of two DWT arrays being merged. This takes as inputs two DWTs, DWT1 and DWT2,
each of length 2k, and outputs a DWT of length 2k+1:
(EQ 3)
The RMF operator is defined recursively on sub-arrays of the original DWTs. The first
half of DWT1 and DWT2 are recursively passed to the RMF operator, and the remaining coeffi-
cients of the two DWTs are concatenated at the end, as shown in Equation (3). The recursion ter-
minates when the length of the DWTs being merged becomes equal to one - at this point the RMF
uses the Haar1 filters h and g, to generate the low pass and high pass coefficients.
DWT in terms of the RMF operator.
A recursive notation for the discrete wavelet transform (DWT) of an array x(n) of length
N=2k, which directly leads to a recursive procedure to compute the DWT is given below.
1. Haar filters are used to develop the RMF method because of their simplicity. We will show how to extend this method for other wavelet filters in Section 3.
RMF[DWT1(0:2k-1), DWT2(0:2k-1)]
= RMF[DWT1(0:2k-1-1), DWT2(0:2k-1-1)] . DWT1(2k-1:2k-1) . DWT2(2k-1:2k-1) if k>0
=RMF[DWT1(0:0), DWT2(0:0)] = h(DWT1(0), DWT2(0)) . g(DWT1(0), DWT2(0)) if k=0
7
(4)
The recursion terminates when the length of the array becomes two. At this point the Haar
filters h and g are applied to generate the low pass and high pass coefficients.
We prove correctness of our algorithm by establishing equivalence of RMF with the FWT
algorithm, which has been proven correct in the literature [12].
Equivalence Theorem . The RMF and FWT methods have input/output equivalence - given an
arbitrary array of 2i data values, both will produce identical arrays of wavelet coefficients.
Proof. The proof is by induction on i. When i=1, or the size of the input array N=2, the RMF
method (using Haar filters) will stop after only one (merge + filter) step, with (s,d) coefficient val-
ues. This is identical to the FWT, and proves the base case.
Let the hypothesis be true for i=k. Using the notation developed in Equation (1) and Equa-
tion (2) to describe the (1-D) DWT, we can use Equation (4) to express the RMF transform recur-
sively in terms of WL(0,1:N), as
DWT [WL(0, 1:N)] = RMF[ DWT[WL(0, 1:N/2)], DWT[WL(0, (N/2)+1:N)] ] (5)
Denoting DWT1 = DWT[WL(0, 1:N/2)], and DWT2 = DWT[WL(0, (N/2)+1:N)], and
applying the RMF operator (Equation (3)) once to the right hand side of Equation (5), we get (in
terms of array indices):
DWT[x(0: 2k-1)] = RMF[ DWT[x(0: 2k-1-1)], DWT[x(2k-1: 2k-1)] ] if k > 1
DWT[x(0: 1)] = [ h(x(0), x(1)), g(x(0), x(1)) ] if k = 1
8
(6)
But, from the induction hypothesis, RMF-DWTs and FWT-DWTs are equivalent up until
array dimensions N/2. Therefore, the latter halves of DWT1 and DWT2 (from Equation (6)) will
be equal to the latter halves of the recursive FWT expansions for this dimension:
FWT(WL(0, 1:N)) = FWT(WL(1, 1:N/2)) . WH(1, 1:N/2) (7)
and so will the front halves, resulting (after back-substitution for DWT1 and DWT2) in:
(8)
and from Equation (4) (back substituting for RMF with the DWT), this becomes:
DWT[WL(0, 1:N)] = DWT[WL(1, 1:N/2)] . WH(1, 1:N/2) (9)
which is equivalent to the expression for the FWT (Equation (7)), thereby proving the input/out-
put equivalence between the FWT and RMF methods.
Complexity Analysis.
It is now easy to show that the complexity of computing the DWT using the RMF algo-
rithm is exactly the same as the Fast Wavelet Algorithm (FWT), i.e. O(N) for an input array x(n)
of length N (e.g. see [6]). Consider Equation (4). The RMF operator (from Equation (3)) takes
only O(1) filter operations to apply the h and g filters on the smooth coefficients from the two
input DWT arrays, the rest of the coefficients are merely copied over in the concatenation order
specified in Equation (3). So we can write
DWT[WL(0, 1:N)] = RMF[DWT1(1: N/4), DWT2(N/2+1 : 3N/4)] . DWT1(N/4 : N/2) . DWT2(3N/4 : N)
DWT[WL(0, 1:N)] . WH(1, 1:N/4) . WH(1, N/4+1:N/2) = RMF[WL(1, 1: N/4), WL(1, N/4+1: N/2)]
9
T(N) = 2T(N/2) + O(1) = O(N) (10)
where T(N) denotes the complexity of computing the RMF transform for input of size N.
3.2 Other Theoretical Properties of the RMF algorithm
In this section, we prove three other important properties of the RMF algorithm.
Invariant Theorem. The following invariant property holds during k successive (merge, filter)
stages of the RMF: after the ith stage, the intermediate (wavelet) coefficients occur as N/2i com-
plete DWTs of successive sub-arrays of the original data array, each sub-array being of length 2i.
This property is obvious from Equation (4), which enforces spatial ordering recursively,
due to the concatenation rule in Equation (4).
Corollary 1: Spatial Coherence Property. After the ith (merge + filter) step of the RMF, the N/2i
complete DWTs occupy exactly those positions of the array, as were occupied by the original data
elements which correspond to their inverse DWT.
This is directly a consequence of the Invariant Theorem, and the fact that there is no fur-
ther migration of coefficients beyond the limits of the two smaller sub-arrays which are merged at
the ith step.
It is difficult to maintain this kind of spatial coherence between input data and transform
coefficients in the Fourier or DCT transform domains, without introducing a significant amount
of positional side-information. This is because Fourier and DCTs don’t have the property of
“localization” like wavelet transforms [7].
Cheap DWT “growing” property. The complexity of combining two arbitrary, complete DWTs,
each of length 2i-1 into a complete DWT of length 2i takes a constant number of filter operations.
10
This is a consequence of the equivalence theorem, and the fact that one merge and filter
step of the RMF only uses the smooth coefficients from the two DWT arrays being merged. Thus,
the complexity of the “filter” part of a RMF operation is independent of the sizes of the coeffi-
cient arrays being merged, and is always equal to one each of h and g.
3.3 Generalization
To be widely applicable to image compression, we need to generalize the new algorithm to
work with different wavelet filters and in higher dimensions than one.
Wavelet Filters.
So far we have developed the RMF only with respect to the Haar wavelets, for simplicity. It is
possible to generalize it for arbitrary quadrature mirror filters (QMFs), h and g, of sizes (length, or
number of taps) htap and gtap respectively, as shown in Equation (11).
11
(11)
The concatenation operations (i.e. copying of high-pass coefficients) which are a part of
the basic RMF operator, as defined in Equation (3) remain the same in Equation (11). Thus, the
“merge” part of the RMF operator remains the same, and only involves two adjacent DWTs (num-
bered i and i+1) at a time. However, the “filter” part of the RMF is modified to apply the QMFs (h
and g) at the smooth coefficients from as many DWTs to the right of the current RMF block, i, as
are needed (e.g. 4 in the case of the D-4 filter) to generate one smooth and one difference coeffi-
cient, while computing the wavelet coefficients for the next octave. Another modification in
Equation (11) is the wrap-around between the first and last RMF blocks, which is needed to
RMF[DWTi(0:2k-1), DWTi+1(0:2k-1)]
= RMF[DWTi(0:2k-1-1), DWTi+1(0:2k-1-1)] . DWTi(2k-1:2k-1) . DWTi+1(2k-1:2k-1) if k>0
= h(DWTi(0), DWTi+1(0), ..., DWTi+htap(0)) . g(DWTi(0), DWTi+1(0), ..., DWTi+gtap(0)) if k=0
12
implement QMFs of length greater than 2, due to the technique of using circular convolutions at
the array boundaries [12].
2-D and Higher Dimensions.
The RMF operator can be defined in 2-D to merge four 2-D DWTs, each of size 2kx2k,
into a larger DWT of size 2k+1x2k+1, using a merge-by-quadrant rule. We will again use the Haar
filters in this exposition. The two-dimensional RMF operator, RMF2D is defined in Equation (12):
(EQ 12)
if k > 1, and for an array of size 2x2, i.e. k = 1, the RMF2D operator is defined as:
WT1(0:2k-1, 0:2k-1) WT2(0:2k-1, 0:2k-1)
WT3(0:2k-1, 0:2k-1) WT4(0:2k-1, 0:2k-1)
= RMF2D WT1(0:2k-1-1, 0:2k-1-1) WT2(0:2k-1-1, 0:2k-1-1)
WT3(0:2k-1-1, 0:2k-1-1) WT4(0:2k-1-1, 0:2k-1-1)
WT1(2k-1:2k-1, 0:2k-1) WT2(2k-1:2k-1, 0:2k-1)
WT3(2k-1:2k-1, 0:2k-1) WT4(2k-1:2k-1, 0:2k-1)
WT1(0:2k-1-1, 2k-1:2k-1) WT2(0:2k-1-1, 2k-1:2k-1)
WT3(0:2k-1-1, 2k-1:2k-1) WT4(0:2k-1-1, 2k-1:2k-1)
WT1(2k-1:2k-1, 2k-1:2k-1) WT2(2k-1:2k-1, 2k-1:2k-1)
WT3(2k-1:2k-1, 2k-1:2k-1) WT4(2k-1:2k-1, 2k-1:2k-1)
RMF2D
Col-wise1-D
Row-wise1-D
RMFs
RMFs
LL HL
LH HH
13
(13)
The notation used in Equation (12) and Equation (13) is explained as follows. The square
brackets are used to denote a 2-D array on which the RMF2D operator is going to be applied. The
four quadrants of the resulting array represent four bands, LL (low, low), HL (high, low), LH
(low, high) and HH (high, high). In Equation (12), the round brackets used in the HL band signify
the application of the 1-D RMF operator on each column of coefficients in that band, and in the
LH band they signify the 1-D RMF operator being applied along each row.
In Equation (12), the RMF2D operator is defined recursively on four complete 2-D DWTs,
WT1, WT2, WT3, and WT4, which are arranged as a square matrix, for notational convenience.
The HH quadrant of the resulting matrix is populated with concatenated coefficients from the HH
bands of the original DWT matrices, in the spatial relationship shown above. Concatenation for
the RMF2D operator is an extension of the 1-D concatenation operation - we maintain the relative
co-ordinate positions of the merged quadrants from the four smaller DWTs.
The HL and the LH bands are also followed by one column-wise 1-D RMF per column,
and one row-wise 1-D RMF per row, respectively, as shown in Equation (12). A column-wise
(row-wise) 1-D RMF is one application of Equation (3) along each column (row), where the first
half of the column (row) is treated as DWT1 and the second half of the column (row) is treated as
DWT2 in Equation (3).
RMF2D
WT1(0: 0) WT2(0: 0)
WT3(0: 0) WT4(0: 0)
=
h h(WT1(0: 0), WT2(0: 0))
g h(WT3(0: 0), WT4(0: 0))
h g(WT1(0: 0), WT2(0: 0))
g g(WT3(0: 0), WT4(0: 0))
14
The recursion of RMF2D continues only on the first quadrant of the matrix. The recursion
terminates when the size of each of the four DWTs being merged becomes 1x1 - at this point the
RMF2D acts as the Haar filters h and g, to generate the low pass and high pass coefficients, as
shown in Equation (13). This is exactly the same as the 2-D FWT algorithm acting on a 2x2 input
array (e.g. see [4]).
3.3.1 Recursive Notation for the 2-D DWT in terms of RMF2D
The use of the RMF2-D operator to formally define the complete 2-D DWT of a matrix of
size 2kx2k follows the same principle as in the 1-D case (Equation (4)), and is shown in recursive
matrix form in Equation (14) (in which A, B, C, and D denote square matrices of equal size). The
pseudo-code for the 2-D DWT follows immediately from Equation (14), and is omitted here for
the purpose of brevity.
(14)
A schematic illustrating how this recursive data flow structure can generate a complete
16x16 DWT from four 8x8 DWTs is shown in Figure 2. The arithmetic complexity analysis for
the 2-D case will also follow the same steps as shown in Equation (10), and result in O(N2) for a
NxN matrix, just the same as FWT.
DWT A B
C D
RMF2DDWT A( ) DWT B( )DWT C( ) DWT D( )
=
DWT a b
c d
RMF2Da b
c d h h a b,( ) h c d,( ),( ) h g a b,( ) g c d,( ),( )
g h a b,( ) h c d,( ),( ) g g a b,( ) g c d,( ),( )= =
15
FIGURE 2. Schematic of building up a complete 16x16 2-D DWT from four 8x8 2-D DWTs with RMF
The 2-D RMF data-flow structure is scalable to higher dimensions. In three dimensions,
the merge-by-octant rule will involve copying cubes instead of squares of data, and so on for
higher dimensions. Thus, the RMF algorithm is recursive in a geometric (i.e. spatial) sense, in
higher dimensions. The 3-D RMF algorithm can be useful for applications which use 3-D data
like voxels (Computer Graphics) or for spatio-temporal image compression using wavelets [9].
The proof of correctness of the 2-D RMF algorithm (by showing input/output equivalence
to the 2-D FWT) is provided in [13], as are arguments leading to the extension of the algorithm in
arbitrary dimensions.
4.0 Application of the RMF data flow
The RMF computation proceeds by successively combining two DWTs of length n into
one of length 2n. In this way, it generates the complete DWT of an array, x(n) of size N, in a bot-
tom-up fashion, by generating the DWTs of length 2, 4, 8, etc., preserving spatial coherence at
1 2
3 4
5 6
7 8
9 10
11 12
13 14
15 16
17 18
19 20
21 22
23 24
25 26
27 28
29 30
31 32
33 34
35 36
37 38
39 40
43
215 6
7 8
9 10
11 121615
141317 18
19 20
21 22
23 2425 26
27 28
29 30
31 32
33 34
35 36
grow1
hrow1
grow2hrow2
....Column-wise 1D RMFs .....
::Row-wise1-D RMFs::
...........
:::
16
each intermediate stage. We show this data flow in Figure 3. Contrast this with the data flow of
the FWT, as shown in Figure 1.
FIGURE 3. Changing the structure of the DWT computation - the RMF structure
The spatial coherence property makes it very conducive for close coupling with wavelet
coding algorithms, and creates the possibility of fine grained as opposed to monolithic encoding.
Recently, there has been considerable interest in using wavelets in image compression (see
[10]). In this section, we will consider two such methods, the Embedded Zero-Tree Wavelet
(EZW) [3] method and the Wavelet-based Hierarchical Vector Quantization (W-HVQ) [2]
method. Typically, such algorithms use the DWT as a black box, using the FWT to compute it,
and then post-process the DWT coefficients to generate the compressed data. We will show that it
is possible to exploit the properties of the altered data flow paradigm of the RMF method, to
reduce the complexity of both these methods, with tighter coupling between the transform stage
and the compression algorithm in each case.
We will also develop a new fine-grained wavelet-based codec for single image and video
compression along the lines of JPEG and MPEG, by using EZW-encoded RMF blocks, instead of
y1
y2
filter
y3
y4
y5
y6
y7
y8
s1
d1
s2
d2
s3
d3
s4
d4
S1
D1
d1
d2
S2
D2
d3
d4
S1
D1
D1
D2
d1
d2
d3
d4
merge &filter
merge &filter
merge &filterY1
Y2 DWT(Y2)
DWT(Y1)
Y DWT(Y)
17
Huffman-encoded JPEG blocks, and provide several arguments as to why this should give an
improvement in performance.
4.1 Application of RMF in W-HVQ Training
The (merge, filter) operation suggests a way of combining two arbitrary DWTs into a
larger DWT, by simply applying O(1) filter applications (for each such operation) at the low-pass
coefficients from each of the smaller DWTs. We will exploit this property to significantly speed
up the W-HVQ training algorithm.
In the paper by Chaddha et. al. [2], block transforms (e.g. Haar, Walsh, etc.) of input vec-
tors of wavelet coefficients of size 2, 4, 8, etc. are stored in hierarchically constructed transform
tables during training. In the training phase, we create a 2-vector codebook, C2, of size N=28; a 4-
vector codebook, C4, of size N=28; a 8-vector codebook C8, of size N=28, and so on. Each of
these codebooks is indexed by two 8 bit numbers. First, each code vector in C2, C4, etc. is con-
structed by training on vectors of size 2x1, 2x2 etc. from the training set, using a standard training
algorithm like GLA [14]. During encoding, each successive stage of table-lookup implicitly per-
forms a 2:1 data compression and an incremental level of DWT, in cascaded fashion (e.g. see [1]).
Figure 4 illustrates the round-about way in which the second and subsequent stage code
vectors of wavelet coefficients are populated. For each entry, a vector representing a wavelet
transform of size 2i+1x2i is obtained by performing two inverse DWTs on the two codewords (of
size 2ix2i) obtained by using the index pairs from the ith stage codebook, followed by a forward
DWT on the block of raw data of size 2i+1x2i (obtained by laying the two inverted blocks side by
side), to obtain the block transform of size 2i+1x2i.
18
Index1 Index2 Output
: : : : : : : : :
2ix2i inversetransform of code
2i+1x2i
ForwardTransform
Compute mindistortion code-word in the i+1stage codebook
Index
ith stage lookup table
vector addressedby Index1
2ix2i inversetransform of codevector addressedby Index2
20
Figure 4. Building successive stage transform tables [2]
The index of the codeword closest to this transformed block in the sense of the distortion
measure being used is selected from all the code vectors in the next (i.e. i+1) stage codebook, and
is written into the corresponding output entry. The complexity of inverting each DWT of length N
is logN, and the complexity of computing the forward DWT of length 2N is log2N. This O(logN)
procedure is repeated at each step of the training algorithm, for all entries (216) in each stage
lookup table.
Using the RMF approach reduces the complexity of the above inverse and forward trans-
forms from 2logN + log2N to O(1), as a consequence of the cheap DWT growing property. This is
shown in Figure 5 below.
Index1 Index2 Output
: : : : : : : : :
Compute mindistortion code-word in the i+1stage codebook
Index
ith stage lookup table RMF DWT1 DWT2
21
Figure 5. Building successive stage transform tables using the RMF algorithm
Constructing larger DWTs from smaller ones is a very frequent operation in the training
phase of algorithms. For example, a W-HVQ encoder may consist of R stages of table lookups
and codebooks. Each lookup table is of size 216. This means that 216 x R of these operations are
required to fill the lookup tables during the training phase. By reducing the complexity of each
such operation by O(logN), RMF reduces the overall complexity of these operations by O(216 x
(log(2) + log(4) + ... + log(2R))) ~ O(216R)1. This significantly reduces the computational com-
plexity of the W-HVQ training algorithm. Experimental results reporting on the improved perfor-
mance of W-HVQ training after using the “cheap DWT growing” of RMF are presented in
Section 5.
4.2 Generating Zero Trees as a by-product of the DWT
Two successful wavelet based image coding algorithms that exploit spatial redundancy
relationships between the wavelet coefficients in a 2-D DWT are the EZW [3] and the SPIHT [8]
coding algorithms. These spatial relationships are parent-child relationships between the nodes of
a special quarternary tree known as a zero tree (Figure 6).
1. This expression is caused by code vectors of size 2 in C2, 4 in C4, etc. (i.e. successive stages of HVQ), and 216 possible address pair lookups at each stage [2]
22
Figure 6. Zero tree
A wavelet coefficient, c, is said to be insignificant with respect to a given threshold T, if
|c|<T. The zero tree algorithms [3], [8] are based on testing the hypothesis (known as the zero tree
hypothesis) that if a wavelet coefficient is insignificant with respect to a given threshold T, then
all its descendants (on the quarternary zero tree) are also likely to be insignificant with respect to
T. If this hypothesis is true then such a coefficient is encoded as a zero tree root (ZTR). If it is
insignificant but one of its descendants is significant then it is encoded as an isolated zero (IZ). If
it is significant then it is encoded as positive (POS) or negative (NEG) according to its sign. A
separate list (called the subordinate list) is also generated that carries the numeric value of each
significant coefficient. This encoding of the zero tree produces significant compression because
gray level images resulting from natural sources typically result in DWTs with many ZTR sym-
bols. Each ZTR informs the decoder that no more bits are needed to encode the descendants of the
corresponding coefficient.
LL3 HL3
LH3 HH3
HL2
LH2 HH2
HL1
HH1LH1
23
The EZW algorithm [3] suffers from a fundamental performance drawback, because the
transform stage and the coding stage are completely decoupled. The zero tree scans (see [3]), i.e.
testing the zero tree hypothesis with respect to each threshold are not started until after the full 2-
D DWT has been computed. The RMF algorithm can speed up the EZW/SPIHT algorithms, by
allowing a tighter coupling between the DWT computing stage and the zero-tree finding stage, so
that the zero-tree can be generated as a by-product of the transform.
4.2.1 The Bottom-Up Zero Tree RMF Algorithm
The new algorithm simultaneously computes the 2-D DWT and the zero trees in bottom-
up fashion. At the ith stage, the complete DWTs of sub-images of size 2ix2i are computed by
applying the RMF2-D operator on the results of the previous (i-1th) step. Simultaneously, the max-
ima of absolute values in each band (HH, HL, LH) are also updated, to aid the zero tree computa-
tion. At any (e.g. ith) step, we may generate the zero tree codes of the sub-images. In this case, we
will not need to explore all the zero tree descendants as in [3]. Instead, we can deduce the code
symbols by using the band-wise maximum values that were propagated in bottom-up fashion.
The Bottom-up Zero Tree RMF algorithm consists of three main steps. Of these, only the
first two are applicable at each intermediate stage. The third step is only applied at the last RMF
step, to generate the zero tree code symbols, from the information generated in a bottom-up fash-
ion from the previous merge and filter steps. The pseudo-code for this algorithm is given in Figure
7. The algorithm is explained below, and is illustrated with an example. First we shall introduce
some basic terminology:
24
• The current_band_max of each band is the maximum absolute value of wavelet coefficients for
that band and its descendant bands, e.g. if 22 is the maximum absolute value in the bands HH2
and HH1, then band_max(HH2) = 22.
• The previous_band_max is the value that is propagated to the next step of the Zero-Tree RMF
algorithm, in order to efficiently generate the current_band_max values, thus propagating the
zero tree computations in a bottom-up fashion.
The band_max updates use the previous_band_max values from each of the four DWTs
participating in the RMF2D operation, and new values of current_band_max and wavelet coeffi-
cients that are generated in the current step of the RMF algorithm. The way in which the current
and previous band_max values are computed varies slightly for the HH, HL and LH bands.
In the new HHi band, current_band_max(HHi) is simply the maximum of the four
previous_band_max(HHi) values, and current_band_max (HHi-1). The current band_max is also
propagated to the next step of the RMF (in which four larger DWTs will be merged) as the
previous_band_max, i.e. previous_band_max(HHi) = current_band_max(HHi).
In the new HLi band, current_band_max(HLi) is the maximum of the four
previous_band_max(HLi) values, the new coefficients generated in the first two rows of the new
HLi by the column-wise 1-D RMF operations (see Equation (12)), and current_band_max(HLi-1).
The new value of the previous_band_max is the maximum of all the coefficients in the new HLi
band, except those in the first row. The reason for leaving out the values from the first row is that
these are the smooth coefficients, which will be replaced by the results of 1-D RMF filter applica-
tions in the next step of RMF2D.
25
Similarly, in the new LHi band, current_band_max(LHi) is the maximum of the four
previous_band_max(LHi) values, the new coefficients generated in the first two columns of the
new LHi by the row-wise 1-D RMF operations (Equation (12)), and current_band_max(LHi-1).
The new value of previous_band_max(LHi-1) is the maximum of all the coefficients in the new
HLi band, except those in the first column.
Step 1. The RMF2D operator is applied to construct a DWT of size 2i+1 x 2i+1 from four smaller
DWTs, each of size 2i x 2i, using Equation (12) and Equation (13).
Step 2. The current and previous values of band_max, i.e. current_band_max and
previous_band_max are updated for each band of the new (new signifies the larger DWT that is
being constructed from the four smaller DWTs) DWT.
Step 3. The third step is applied at the RMF step at which code is to be generated. This could be
the final step of the complete DWT, or an earlier stage if fine-grained (i.e. sub-image level) cod-
ing is being done (see Section 3.3.3). The zero tree symbols with respect to each threshold, T, are
generated for each node of the DWT in increasing order of octaves, i.e. octaves 1 through n, in the
following manner. If the absolute value of the coefficient is greater than T, then it is encoded as
POS or NEG (according to whether it is positive or negative). If it is insignificant, and the
band_max of the band containing its immediate children is also insignificant, then it is encoded
with the symbol 0. For example, for threshold T = 32, if a parent node in band HL2 has a value of
28 and band_max(HL1) = 24, then that node is encoded with 0. If the octave of the parent node is
also the highest octave in the DWT, or fine grained codes are to be generated at that octave, then
the symbol ZTR is used instead of 0. If the coefficient is insignificant, but the band_max of the
band containing its immediate children is significant, then we examine the code for each of its
26
four children. If they are all 0, then the coefficient is also encoded as 0 (or ZTR at the final octave
level). If they are not all 0, then the parent node is encoded with the IZ symbol.
The pseudo-code for the bottom up algorithm is given in Figure 7 below. WT1, WT2,
WT3 and WT4 are the four smaller DWTs that are inputs into the current step of the algorithm.
The notation WT1:WT4 denotes “from WT1, WT2, WT3 and WT4”.
4.2.2 A Simple Example
In this sub-section, a simple example will be used to highlight the order of operations in
the Bottom-Up Zero Tree RMF algorithm, with reference to Figure 8. In this step of the algo-
rithm, four DWTs of size 4x4 are merged and filtered, the band_max values are updated, and the
zero tree codes are generated for the threshold, T = 32. This example has been chosen such that
the end result is exactly the same as that obtained in an example worked out by Shapiro to illus-
trate the EZW algorithm [3], and by Rao and Bopardikar to illustrate the SPIHT algorithm [15].
Thus, for this example, we are able to verify input/output equivalence with these other two algo-
rithms that are also based on zero tree coding.
27
Figure 7. Bottom-up Zero Tree RMF algorithm working on four 2kx2k DWTs
WT1(0:2k-1, 0:2k-1) WT2(0:2k-1, 0:2k-1)
WT3(0:2k-1, 0:2k-1) WT4(0:2k-1, 0:2k-1)
RMF2D
ALGORITHM Bottom Up Zero Tree RMF (Inputs 2D_DWT: WT1, WT2, WT3, WT4){
for octave = 1 to k+1 do /* Step 2
/* Step 1 RMF2D */
current_band_max (HHoctave) = max (maxWT1:WT4( previous_band_max (HHoctave), current_band_max ( HHoctave-1)) previous_band_max (HHoctave) = current_band_max (HHoctave) current_band_max (HLoctave) = max (maxWT1:WT4( previous_band_max (HLoctave), max (1st two rows in HLoctave), current_band_max (HLoctave-1)) previous_band_max (HLoctave)
= max (maxWT1:WT4( previous_band_max (HLoctave), max ( second row in HLoctave)) current_band_max (LHoctave) = max (maxWT1:WT4( previous_band_max (LHoctave), max (1st two columns in LHoctave), current_band_max (LHoctave-1))
} endif done; else if all four children nodes are encoded 0 encode as 0, else encode as IZ
previous_band_max (LHoctave)
else if current_band_max(band of immediate children) is insignificant encode 0 if node is significant then if (node > 0) then encode POS else NEG
for ∀ THRESHOLDS and ∀ nodes in octaves 1 to k+1 do
if EZW coding at this level is required /* Step 3 Generate the Zero Tree codes */
= max (maxWT1:WT4( previous_band_max (LHoctave), max ( second column in LHoctave))done
Update current and previous band_max values */
28
Figure 8 illustrates how the DWT coefficients are generated by merging and filtering the
coefficients from the four smaller DWTs. It also shows how the current_band_max values (for the
HH1 and HH2 bands) are computed at the current step, by using the previous_band_max values
from the four DWTs, and current_band_max values from lower octave bands.
21 63 10 17
29 3 5 -7
6 4 -1 4
3 -3 3 -2
43 -3 -6 6
1 -12 3 9
2 -2 47-14
3 2 0 4
37 35 4 9
-16 -14 4 -2
6 3 6 -1
16 5 0 3
151 23 -18 8
-2 8 3 2
6 3 -4 5
-6 6 -4 4
current_band_max(HH1)= previous_band_max(HH1) = 6
HH1
HL1
LH1
HL2
HH2LH2
LL2
current_band_max(LH1) = 6previous_band_max(LH1) = 6
63 -34 49 10
-31 23 14 -13
-12 3 14 15
-9 -7 -14 8
7 13 -12 7
3 4 6 -1
9 3 -7 5
4 -2 3 2
-5 9 -1 47
3 0 -3 2
-4 6 -3 2
5 11 5 6
4 6 -2 2
3 -2 0 4
6 3 6 3
0 3 -4 4
Bottom-Up Zero Tree Algorithm
previous_band_max(HH1) = 4
previous_band_max(HH1)=6
previous_band_max(HH1) = 6
current_band_max(HH1)= max ( 6, 4, 6, 6) = 6
HH1
HH2current_band_max(HH2)= max ( max (3, 12, 14, 8), current_band_max(HH1)
= max (14, 6) = 14 )
Code generated = ZTR
HH3
29
Figure 8. Example of the Bottom-up Zero Tree Algorithm (3-scale DWT)
The value of the HH3 coefficient generated by the RMF algorithm, 23, is insignificant
with respect to the threshold T = 32. The current_band_max of HH2 band is 14, which is also
insignificant. Therefore, the code symbol generated for this coefficient is ZTR. Note that in this
case we could find the ZTR code for the HH3 coefficient much faster than the EZW algorithm, in
which we would first have to explore all 20 descendants from the HH2 and HH1 bands.
4.3 Fine-Grained Wavelet Codecs using EZW-Encoded 2-D RMF (DWTs)
Because the RMF algorithm builds up a 2-D DWT in a bottom-up fashion, in incremental
steps of complete 2x2, 22x22, ...., 2logNx2logN DWTs, then each of these intermediate DWTs can
also be individually EZW-encoded. The advantages of using a block codec based on EZW coding
of RMF wavelet transforms are the following:
• it is possible to encode any block size, e.g. 8x8, 16x16, etc., and even dynamically adapt the
block size to the desired granularity and network traffic. This is not possible with FWT
encoded with EZW, or with JPEG/MPEG, where the block sizes are pre-set. This flexibility is
very readily (and inexpensively) provided by the RMF algorithm, as it only takes
filter operations to operate at double the current block size. As the
algorithm constructs the 2-D DWT in a bottom-up fashion, therefore operating at any 2ix2i
block size possible.
• we do not suffer blocking artifacts by using overlapping wavelet filters like D-4. As block-
based DCT codecs like JPEG and MPEG do not use any information from neighboring blocks,
ON
2
CurrentBlockSize( )2-------------------------------------------------------
30
at low bit rates this gives rise to a “blocky” appearance. By using D-4 or longer wavelet filters
that use support from across block boundaries, this problem is minimized.
• no training or pre-stored tables or codebooks are required. JPEG/MPEG use Huffman tables
which are based on perceptual prediction of insignificant DCT coefficients, at each operational
quantization level. This means that a large number of these tables need to be stored, but if the
image types are significantly different than the perceptual predictions, then PSNR deterioration
will become visible. By contrast, EZW [3] is based on testing if the zero tree insignificance
hypothesis is true, and if it is violated, then all significant coefficients, even those at high fre-
quencies, are transmitted (see also the discussion on trends and anomalies in [3]). This leads to
better PSNR performance than JPEG/MPEG, especially at very low bit rates (or equivalently,
at high quantization rates).
• using the fact that the zero trees can be generated in a bottom-up fashion, as a by-product of the
RMF algorithm, can also lead to a performance boost over FWT/EZW, by eliminating the iter-
ative parent-child scans [3], thus bringing it closer to interactive speeds for use in a new video
codec like “wavelet-MPEG”. Each RMF block will still need to be arithmetic coded, and the
overall complexity of the encoder will still be higher than MPEG, which uses pre-defined Huff-
man tables, but much better than FWT/EZW, which cannot operate in a block-based mode.
What truly gives our approach an added level of flexibility, is that it will be very easy to change
bit rates and even block dimensions on the fly, and still use the zero tree information that is in
the (bottom-up RMF) pipeline. This information can be used to construct the zero trees at the
next level up (i.e. at the next larger block size), or it already has all the zero tree information for
the next level down (i.e. at the next smaller block size).
31
Fine-grained wavelet coding is a very exciting (and possibly widespread) impact that the
RMF algorithm can have in the field of image compression. Experimental results showing the
fine-grained image encoding using the RMF algorithm are shown in Section 5.
5.0 Experimental Results
We ran experimental evaluations of the RMF algorithms along the lines of: a) execution
time in comparison with FWT; b) W-HVQ training time with and without the “cheap DWT grow-
ing” of the RMF; c) EZW coding with and without the RMF algorithm generating the zero-trees
as by-products; and d) fine-grained codes for sub-images.
Experimental Setup. In our testing we used a SUN Sparc 10 computer, running SunOS 5.6. The
computer has three processors, each of which runs at 248 MHz and has an additional Sparc float-
ing point processor attached to it. The combined main memory is 768 MB. Multiple users were
using the computer when we ran our experiments. C programming was used for all the implemen-
tations. The SPIHT (an EZW-like algorithm) that we used for comparing execution time with our
algorithm was provided by Profs. Said and Pearlman, of the Center for Image Processing
Research, Rensellaer Polytechnic Institute (downloaded from the web-based resource: http://
ipl.rpi.edu/SPIHT/spiht1.html).
The first series of experiments compare the execution time for 1-D and 2-D DWTs gener-
ated by the RMF and FWT methods, for different sizes of input arrays. These are tabulated in
Table 1 and Table 2.
32
It can be seen that the 1-D RMFs and FWTs run in almost exactly the same amount of
time, as is predicted by the analysis of complexity in Section 3. However, the 2-D RMF is slightly
slower (about 5-8%) than the 2-D FWT (Table 2). This could be attributed to the implementation
and paging overheads caused by the data movement of the merge and filter operations of the
RMF2D operator.
The second series of experiments compare the execution times for the W-HVQ training
phase with and without the “cheap DWT growing” of RMFs, for various levels of acceptable dis-
tortion. The lower the training parameter of the GLA training algorithm [14], the lower is the
acceptable distortion in the final codebooks, and the longer the training must go on (e.g. see [14]
for more on the GLA training parameter). In these experiments we used a training set of five stan-
dard images: Barbara, Boat, Peppers, Goldihill and Zelda to generate the codebooks. Each of
Table 1: Comparison of 1-D RMF and 1-D FWT Execution Times
Size RMF FWT
128 1.3 ms 1.3 ms
256 2.7 ms 2.7 ms
512 5.2 ms 5.18 ms
Table 2: Comparison of 2-D RMF and 1-D FWT Execution Times
Size RMF FWT
128x128 3.1 ms 2.8 ms
256x256 6.5 ms 5.1 ms
512x512 28.32 ms 25.9 ms
33
these is a 512x512 gray level image. It can be seen that for low distortion the RMF method makes
a very significant dent in the overall time to build the codebooks, in Table 3. At high distortion,
training is fast with either method, as the GLA training itself dominates the execution time.
The third series of experiments compares the execution time of the EZW algorithm (using
the SPIHT implementation [8]) with and without our modification of generating the zero-trees as
by-products of the DWT computation with the 2-D RMF algorithm. These statistics (execution
time in milli seconds) are provided in Table 4.
It can be seen that the bottom up algorithm shows maximum speedup at low bit rates. At
these bit rates more zero tree root (ZTR) symbols are formed, and the bottom up algorithm saves
Table 3: Impact of RMF on W-HVQ training
GLA parameter
FWT RMF
0.1 6m 25sec 6m 5sec
0.01 14m 10sec 10m 40sec
0.001 32m 24sec 24m 15sec
Table 4: Impact of RMF on EZW/SPIHT encoding times (milli seconds)
Bit RateSPIHT without
RMFSPIHT with
RMF
4 bpp 2,350 2,230
2 bpp 1,870 1,780
1 bpp 1,170 1,115
0.5 bpp 820 784
34
us the effort of searching the immediate children of these coefficients. At higher bit rates the zero
tree hypothesis is violated more often, which means that the immediate children of the high level
coefficients need to be examined and codes generated for them.
The fourth series of experiments shows sub-images that are generated by the RMF algo-
rithm, which can be used to generate fine-grained sub-image level code using the EZW or other
wavelet based codecs. In Figure 9 below, we display an image (of size 256x256), which was
reconstructed from EZW-encoded RMFs (for the same image) at a block size of 64x64.
Figure 9. Image reconstructed from block-based EZW-encoded RMF data.
35
6.0 Conclusions and Future Work
In this paper, we have proposed the Recursive Merge-Filter (RMF) algorithm for comput-
ing the Discrete Wavelet Transform, and shown that it has the nice properties of a data flow struc-
ture which is geometrically recursive, i.e. fractal in nature, and extends to higher dimensions.
Unlike the FWT, it has the nice property of maintaining spatial coherence with the input data, and
provides an extremely efficient way of building larger wavelet transforms from smaller ones,
without first inverting the smaller DWTs. We have demonstrated one application area (W-HVQ
training) where this “DWT growing” property can drastically reduce the computing time, and one
(EZW/SPIHT) in which the bottom-up tree growing nature of the RMF algorithm, combined with
the spatial coherence property of RMF can concurrently generate the zero tree significance map
as a by-product of the transform. We have also offered the new capability of fine-grained (or sub-
image level) wavelet coding, by using block-wise wavelet transforms (encoded with EZW) as an
alternative to the DCT in JPEG or MPEG codecs.
This work brings up several interesting possibilities for future research:
1) We propose to investigate extending the RMF algorithm to compute the inverse DWT. This
may be relevant for those kinds of DSP, where the preferred or “natural” domain is the transform
(e.g. frequency) domain, e.g. audio and control systems, and where one may be interested in the
intermediate results of taking the inverse transform. For orthogonal transforms, this extension of
the RMF is expected to be easy, as the computational structure is typically the same in both for-
ward and reverse directions for such transforms;
2) It would be interesting to characterize transforms that maintain spatial coherence, and the prop-
erties that they need to exhibit in order to use the RMF data flow, e.g. locality [7];
36
3) Look for ways of improving the performance of EZW, by utilizing the “smooth” coefficient
values at each step of the RMF transform algorithm in constructing the zero tree significance
maps. These values correspond to local spatial averages, which are not available in the final
DWT, at which point the EZW/SPIHT algorithms proposed in the literature start their encoding;
4) We propose to use the RMF algorithm instead of DCT, and the EZW encoding algorithm
instead of Huffman, thus giving new MPEG and JPEG codecs, which have the capability of gen-
erating fine grained (i.e sub-image level) codes, using wavelet transforms.
5) Our implementation of the 1-D and 2-D RMF operator is stateless. Thus, they are obliv-
ious to the type of overall computations for which they are being used, e.g. fine grained coding,
constructing larger DWTs by combining smaller ones, or in computing the end-to-end DWT of an
input array. This re-usable “black-box” design can be incorporated relatively easily into re-config-
urable hardware, parallel algorithms and large software systems in future research.
REFERENCES
[1]M. Vishwanath and P. Chou, “An Efficient Algorithm for Hierarchical Compression of Video”,
Proc. ICIP - 1994, Austin, Texas, vol. 111, pp. 275-279, November 1994.
[2]N.Chaddha, V.Mohan and P.Chou, “Hierarchical vector quantization of perceptually weighted
block transforms”, Proc. Data Compression Conference, IEEE, Piscataway, NJ, pp.3-12, 1995.
[3]J. Shapiro, “Embedded image coding using zero trees of wavelet coefficients”, IEEE Transac-
tions on Signal Processing, vol. 41, no. 12, pp. 3445-3462, December 1993
[4]W.H.Press, et.al., Numerical Recipes in C, 2nd edition, Cambridge University Press, 1992.
37
[5] S. G. Mallat, “A Theory for Multiresolution Signal Decomposition: The Wavelet Representa-
tion”, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol.11, no.7, pp. 674-
693, July 1989.
[6] A. D. Poularikas, The Transforms and Applications Handbook, CRC Press Inc., 1996.
[7] M. Vetterli and J. Kovacevic, Wavelets and Subband Coding, Prentice Hall, 1995.
[8] A. Said and W. A. Pearlman, “A new fast and efficient image codec based on set partitioning
in hierarchical trees”, IEEE Transactions on Circuits and Systems for Video Technology, Vol. 6,
No. 6, pp. 243-250, June 1996.
[9] J. -R. Ohm, “Three-dimensional subband coding with motion compensation”, IEEE Transac-
tions on Image Processing, Vol. 3, No. 5, 1994.
[10] C. I. Podilchuk and R. J. Safranek, “Image and video compression: A review”, International
Journal of High Speed Electronics and Systems, Vol. 8, No.1, pp. 119-177, 1997.
[11]M. Vishwanath, “The Recursive Pyramid Algorithm for the Discrete Wavelet Transform”,
IEEE Transactions on Signal Processing, Vol. 42, No. 3, 1994.
[12]S.G. Mallat, A Wavelet Tour of Signal Processing, Academic Press, 1997.
[13]K.Mukherjee, “Image Compression and Transmission using Wavelets and Vector Quantiza-
tion”, Ph.D. thesis, University of Central Florida, 1999.
[14] A. Gersho, A. and R.M. Gray, Vector Quantization and Signal Compression, Kluwer Aca-
demic Publishers, 1992.
[15]R.M. Rao and A.S. Bopardikar, Wavelet Transforms: Introduction to Theory and Applica-
tions, Addison-Wesley Longman Inc., 1998.
38