matlab qtdecomp,Quadtree decomposition

qtdecomp

Quadtree decomposition

Description

S = qtdecomp(I)

performs a quadtree decomposition on the grayscale image I and

returns the quadtree structure in the sparse matrix S. By

default, qtdecomp splits a block unless all elements in the block

are equal.

S = qtdecomp(I,threshold)

splits a block if the maximum value of the block elements minus the minimum value of

the block elements is greater than threshold.

mindim, even if the

resulting blocks do not meet the threshold condition.

mindim or larger than

maxdim. Blocks larger than maxdim are

split even if they meet the threshold condition.

S = qtdecomp(I,fun)

uses the function fun to determine whether to split a

block.

Examples

Perform Quadtree Decomposition of Sample Matrix

Create a small sample matrix.

I = uint8([1 1 1 1 2 3 6 6;...

1 1 2 1 4 5 6 8;...

1 1 1 1 7 7 7 7;...

1 1 1 1 6 6 5 5;...

20 22 20 22 1 2 3 4;...

20 22 22 20 5 4 7 8;...

20 22 20 20 9 12 40 12;...

20 22 20 20 13 14 15 16]);

Perform the quadtree decomposition and display the results.

S = qtdecomp(I,.05);

disp(full(S));

4 0 0 0 4 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

4 0 0 0 2 0 2 0

0 0 0 0 0 0 0 0

0 0 0 0 2 0 1 1

0 0 0 0 0 0 1 1

View Block Representation of Quadtree Decomposition

Read image into the workspace.

I = imread('liftingbody.png');

Perform the quadtree decomposition and display the block representation in a figure.

S = qtdecomp(I,.27);

blocks = repmat(uint8(0),size(S));

for dim = [512 256 128 64 32 16 8 4 2 1];

numblocks = length(find(S==dim));

if (numblocks > 0)

values = repmat(uint8(1),[dim dim numblocks]);

values(2:dim,2:dim,:) = 0;

blocks = qtsetblk(blocks,S,dim,values);

end

end

blocks(end,1:end) = 1;

blocks(1:end,end) = 1;

imshow(I)

figure

imshow(blocks,[])

Input Arguments

I — Grayscale image

m-by-n numeric matrix

Grayscale image, specified as an

m-by-n numeric matrix. If the

syntax includes a function handle, fun, then the image

can be of any class supported by the function.

Data Types:single | double | int16 | uint8 | uint16 | logical

threshold — Threshold of block homogeneity

scalar in the range [0, 1]

Threshold of block homogeneity, specified as a scalar in the range [0, 1].

If I is of class

uint8, then qtdecomp

multiplies the value of threshold by 255 to

determine the actual threshold to use.

If I is of class

uint8, then qtdecomp

multiplies the value of threshold by 65535

to determine the actual threshold to use.

mindim — Minimum block dimension

positive integer

Minimum block size, specified as a positive integer.

mindim must be a factor of the image size.

maxdim — Maximum block dimension

positive integer

Maximum block size, specified as a positive integer.

maxdim/mindim

must be a power of 2.

fun — Function handle

handle

Function handle, specified as a handle. The function must accept as input

all m-by-m blocks stacked into an

m-by-m-by-k

array, where k is the number of blocks. The function must

return a logical k-element vector, whose values are

1 if the corresponding block should be split, and

0 otherwise. For example, if

k(3) is 0, then

the third m-by-m block should not be

split.

For more information about function handles, see Create Function Handle.

Output Arguments

S — Quadtree structure

sparse matrix

Quadtree structure, returned as a sparse matrix. If

S(k,m) is nonzero, then (k,m) is

the upper left corner of a block in the decomposition, and the size of the

block is given by S(k,m).

Data Types:double

Tips

qtdecomp is appropriate primarily for square images whose

dimensions are a power of 2, such as 128-by-128 or 512-by-512. These images can

be divided until the blocks are as small as 1-by-1. If you use

qtdecomp with an image whose dimensions are not a power

of 2, at some point the blocks cannot be divided further. For example, if an

image is 96-by-96, it can be divided into blocks of size 48-by-48, then

24-by-24, 12-by-12, 6-by-6, and finally 3-by-3. No further division beyond

3-by-3 is possible. To process this image, you must set

mindim to 3 (or to 3 times a power of 2); if you are

using the syntax that includes a function, fun, the

function must return 0 at the point when the block cannot be

divided further.

Algorithms

The qtdecomp function divides a square image into four equal-sized

square blocks, and then tests each block to see if it meets some criterion of

homogeneity. If a block meets the criterion, it is not divided any further. If it does

not meet the criterion, it is subdivided again into four blocks, and the test criterion

is applied to those blocks. This process is repeated iteratively until each block meets

the criterion. The result can have blocks of several different sizes.

Introduced before R2006a