**Name**

**biowave2** Computes the biorthogonal wavelet transform of an image

**Command Synopsis**

**biowave2** [-r *NLevel*] [-h *HaarNLevel*] [-e *EdgeMode*] [-n *FilterNorm*] *Image* *WavTrans* *ImpulseResponse1* *ImpulseResponse2*

-rNLevel: Number of levels (default 1)

-hHaarNLevel: Continue decomposition with Haar filter until level HaarNLevel

-eEdgeMode: Edge processing mode (0/1/2, default 2)

-nFilterNorm: Normalization mode for filter bank (0/1/2, default 0)

Image: Input image (fimage)

WavTrans: Output wavelet transform of Image (wtrans2d)

ImpulseResponse1: Impulse response of filter 1 (fsignal)

ImpulseResponse2: Impulse response of filter 2 (fsignal)

**Function Summary**

void biowave2 (NumRec , Haar , Edge , FilterNorm , Image , Output , Ri1 , Ri2 )

int *NumRec ;

int *Haar ;

int *Edge ;

int *FilterNorm ;

Fimage Image ;

Wtrans2d Output ;

Fsignal Ri1 , Ri2 ;

**Description**

*biowave2* computes the two-dimensional discrete wavelet transform
of the floating point image stored in the file *Image*,
using filter banks associated to biorthogonal bases of wavelets.
See *owave1* and *biowave1* modules' documentation for definitions
and notations and refer to [CDF92] for the theory.

As in *owave2* module, this transform is semi-separable, i.e. it can be
decomposed at each level in two one-level and one-dimensional wavelet
transforms applied successively on the lines and on the columns of the image.
It corresponds to separable multiresolution analysis and semi-separable
wavelet bases on
*L*^{2}(*I**R*^{2}).
The one-dimensional algorithm is the one that is implemented in
*biowave1*, and the multidimensional construction is the same
as that of the orthogonal case (*owave2*). The reader is refered
to the documentation of these modules for their description.

At each step the average sub-image is splitted into four sub-images,
corresponding to the four generating functions
(*x*)(*y*),(*x*)(*y*),(*x*)(*y*),(*x*)(*y*).

The different methods for computing the edge coefficients are the same as
in the univariate case (see *biowave1*), unless the dimensions of the
image are not multiples of 2^{J}. Then the processing is done in the same
way as in the 2D orthogonal case (see *owave2* module documentation).

As for orthogonal decomposition, the size of sub-images is divided by four
at each step, so that the total size of the wavelet transform is equal
to the size of the original image, and the number *J* of levels
in the decomposition is upperbounded.

The complexity of the algorithm is
(2 - 2^{-J+1})(*N* + ) *dx* *dy*
multiplications and additions, where *dx* and *dy* are respectively
the number of columns and the number of lines in the original image.

The resulting sub-images *A*_{J},
*D*^{1}_{1}, *D*^{1}_{2},..., *D*^{1}_{J},
*D*^{2}_{1}, *D*^{2}_{2},..., *D*^{2}_{J}, and
*D*^{3}_{1}, *D*^{3}_{2},..., *D*^{3}_{J} are stored in files having all the same prefix *Wavtrans*. The name of the file is *prefix_j_A.wtrans2d* for *A*_{j} and *prefix_j_D.wtrans2d* for *D*_{j}.

The coefficients (*h*_{k}) and
() of the filter's impulse responses are read in the file *ImpulseResponse1* and *ImpulseResponse2*.

- The -r, -h and -e options are exactly the same as in the orthogonal transform.
See
*owave2*module documentation for explanations. - The -n option specifies the normalisation mode of the filter impulse responses' coefficients. Be careful, the normalisation possibilties are slightly different from the 1D case.
- 0 No normalisation occurs.
- 1
=
*h*_{k},*h*_{k}= 1.0 - 2
=
*h*_{k}^{2},*h*_{k}= 1.0

**See Also**

**Version 1.4**

Last Modification date : Thu Jan 31 15:01:50 2002

**Author**

Jean-Pierre D'Ales