IEEE TRANSACTIONS ON IMAGE PROCESSING, VOL. 16, NO. 4, APRIL 2007
1131
Binary Partition Tree Analysis Based on Region
Evolution and Its Application to Tree Simplification
Huihai Lu, John C. Woods, Member, IEEE, and Mohammed Ghanbari, Fellow, IEEE
Abstract—Pyramid image representations via tree structures are
recognized methods for region-based image analysis. Binary partition trees can be applied which document the merging process
with small details found at the bottom levels and larger ones close
to the root. Hindsight of the merging process is stored within the
tree structure and provides the change histories of an image property from the leaf to the root node. In this work, the change histories are modelled by evolvement functions and their second order
statistics are analyzed by using a knee function. Knee values show
the reluctancy of each merge. We have systematically formulated
these findings to provide a novel framework for binary partition
tree analysis, where tree simplification is demonstrated. Based on
an evolvement function, for each upward path in a tree, the tree
node associated with the first reluctant merge is considered as a
pruning candidate. The result is a simplified version providing a
reduced solution space and still complying with the definition of a
binary tree. The experiments show that image details are preserved
whilst the number of nodes is dramatically reduced. An image filtering tool also results which preserves object boundaries and has
applications for segmentation.
Index Terms—Binary partition tree (BPT), image segmentation,
region-based analysis.
I. INTRODUCTION
O
BJECT extraction from images and databases continues
to confound the research community despite a wealth
of tools available to exploit the results. Region-based image
analysis represents a reduced space which is tractable for such
a problem. Regions are often subjected to a merging process
which can be documented in a tree structure. The resultant
tree provides a hierarchical region-based image representation
where the history of the entire merging process is available.
In literature, research effort in tree-based image analysis has
been focused on formation of the tree structure itself [1]–[3] and
direct examination of statistics of each tree node by transversal
of the tree levels [1], [4]. The true value of hindsight of the
merging process as stored in the tree has yet to be fully explored.
In this work, we propose a novel framework for the analysis of
tree-based image representations to take advantage of the information which is already available in the tree. Given a particular image property to consider, i.e., color or size, we analyze the second order statistics of its evolution or change history from a leaf to the root node. The framework is generic in
Manuscript received February 24, 2006; revised December 8, 2006. The associate editor coordinating the review of this manuscript and approving it for
publication was Dr. Anil Kokaram.
The authors are with the Department of Electronics Systems Engineering,
University of Essex, CO4 3SQ, Colchester, Essex, U.K. (e-mail: hlu@essex.
ac.uk; [email protected]; [email protected]).
Digital Object Identifier 10.1109/TIP.2007.891802
a sense that other user specified image properties can also be
applied. The second order statistics are realized by a so-called
knee function [5]. The knee value at a tree node shows the reluctancy of the merge occurring at that particular node. The term of
“reluctancy” used here is to describe how unwilling two adjacent regions merge together. One immediate application of this
framework is to simplify the tree. Trees are normally generated
using over-segmented region space [6] and, thus, contain a large
amount of semantically redundant information. By examining
the knee values, the tree nodes on which reluctant merges occurred can be identified, and all their subbranches removed. A
simplified tree is not only desirable for good visualization, but
also saves considerable computational load for the further analysis stages. A by-product of our tree simplification is an image
filtering tool which preserves the boundaries of salient objects
and has applications for segmentation.
The particular tree structure employed in this work is the binary partition tree (BPT) [1]. There are other options available
in the literature, e.g., max-tree [7], segmentation quadtree [8],
etc., where the proposed framework is also applicable. The BPT
of an input image is derived from the Watershed transform [9]
of the original image. A detailed BPT generation pipeline is
given in Section II. The BPT provides an efficient hierarchical
region-based image representation, in which object extraction is
possible by directly examining region properties. This is known
as the tree browsing and can be done either with a human in
the loop [10] or automatically by evaluating each tree node according to some criterion [1], [4]. However, the BPT is often not
suitable for human interaction because the graphical representation is too dense and complicated, making tree browsing difficult
or sometimes impossible; hence, a tree simplification technique
is desired. In this paper, the term tree simplification refers to the
action of reducing the number of tree nodes. If the automatic
evaluation is employed, computational load in the BPT is dependent on the number of tree nodes. Whilst many techniques
are linear with the number of nodes [1], [4], the tree simplification is especially important when computation is nonlinear.
In general, given a BPT, the tree nodes at lower branches are
composed of small homogeneous image areas which have no
clear semantic meanings and contain a large amount of semantically redundant information. Therefore, the tree simplification
is a technique which tries to minimize this redundant information. It is possible by a) controlling the transformation used to
generate the initial region space, reducing the number of initial
regions output by the Watershed transform, and b) modifying
the tree structure itself. Simplification in the presegmentation
pipeline is ill advised for our purposes since some image detail
may be permanently lost in the final tree. Furthermore finding
1057-7149/$25.00 © 2007 IEEE
1132
IEEE TRANSACTIONS ON IMAGE PROCESSING, VOL. 16, NO. 4, APRIL 2007
optimum values for thresholds restates the difficulties of traditional image processing techniques in the pixel domain. Modification in the tree structure is more preferable and is the strategy
adopted here. By doing so, the BPT formation process is completely separate from the tree analysis stage. In [1], a pruning
strategy followed by a marker propagation technique is proposed. This was provided as an image filtering tool and can also
be viewed as a tree simplification technique since the resultant
tree contains fewer nodes than the original. Our work deviates
from this in the following fundamental ways. First, in [1], tree
branches are pruned according to a threshold criterion such as
size, one node at a time. In case where semantic areas are small,
essential image content is lost. As an alternative what we do is
to filter the tree by analysing the bottom-up evolution of statistics from leaf to root node. No threshold is directly imposed on
the tree nodes which gives the user greater flexibility to control
the pruning process. Second, a tree simplified by [1] gives rise to
many trunk branches which have had their subbranches and leaf
nodes removed. Therefore, the resulting trees may no longer be
binary trees since some parents will not have two child nodes.
They do not, therefore, lend themselves to further binary tree
processing techniques. Our approach simplifies the tree whilst
still complying with the binary tree definition.
Organization of the paper is as follows. Section II describes
the techniques adopted to generate the BPT. In Section III, we
introduce our novel framework for tree-based image analysis.
An immediate application of this framework, the tree simplification, is presented in Section IV. Finally, conclusions are drawn
in Section V.
II. BPT GENERATION PIPELINE
The BPT generation pipeline implemented in this work can
be generalized as follows [10].
1) Presegmentation. A color image is processed using a
Watershed transform [9]. The result is an over-segmented
graph containing many small and often semantically
meaningless regions. These regions are then uniquely
labelled and the statistics of each region are collected for
further analysis.
2) Merging process. The presegmentation is followed by the
computation of a region adjacency graph (RAG). The initial RAG is then subjected to a merging process which examines statistics between neighboring regions and merges
the most similar pair into a single region. The RAG map is
updated accordingly. The merging process continues until
a single node covering the whole image area has been
formed.
3) Binary partition tree. The merging process is logged using
the BPT. If visualization is required, the tree is parsed and
drawn by a dynamic tree drawing algorithm [11].
By ordering regions according to similarity and merging only
the pair that are most similar, the process is threshold-free and
does not require user intervention. Furthermore, there is only a
single outcome for a given presegmentation. In the BPT, the historical progression of an individual region is available. Therefore, we have hindsight. This hindsight tells us where the salient
merges are.
Fig. 1. Example of the BPT. (a) Original image. (b) Its associated BPT.
The merging algorithm used here is adapted from [1]. Let
denote the th region in the tree. The merging process is
and a merging order,
uniquely specified by a region model
which are defined as follows.
Each region is modelled by its mean color in the CIE L*a*b*
is, therefore, given by
color space. The region model for
where
is the number of pixels in region , and
is
the color vector of the th pixel.
and
The merging order for a pair of adjacent regions
is defined as
where
denotes
norm.
An example BPT generated from the Akiyo sequence is
shown in Fig. 1. Akiyo is regarded by the research community
as an easy test sequence for foreground/background separation
and object-based coding like MPEG-4. However, the tree in
Fig. 1(b) shows the density of regions generated by the immersion process and how complex the browsing of the tree can be.
In general, real-world images result in a large number of initial
regions but the boundaries and semantic detail are preserved.
III. EVOLVEMENT ANALYSIS—A NOVEL WAY TO
EXPLORE INFORMATION IN A TREE
From the subjective tests conducted in [10], it is believed that
the evolvement history of region features plays an important
role in tree browsing. In this section, we formulate this finding
in a systematic way to provide a novel framework for binary
partition tree analysis.
denote the set of leaf nodes in
Let
the tree, where is the number of leaf nodes. From each leaf
to the root node, a unique upward path
is defined. Let
denote the number of tree nodes (levels) along the path ;
denote the index of the tree level where
means the
bottom level, i.e., the leaf node. Since the BPTs are generally
might be different among the paths.
unbalanced binary trees,
An evolvement is defined as the changing history of a given
region feature along a path . It is a function of tree level
and denoted as
. In the following, we have dropped the
path condition from the evolvement function for easy notation.
LU et al.: BINARY PARTITION TREE ANALYSIS
1133
Fig. 2. Example of evolvement analysis.
A number of different region features may be extracted
from a tree node according to its underlying image properties.
This makes the definition of an evolvement function quite
flexible, with each of its possible variants having different
characteristics. In order to simplify analysis and create a unified
framework, the evolvement function is required to monotonically increase as progresses from leaf to root. This restriction
applies only to the evolvement, and not to the feature itself,
which can have any distribution. There is, therefore, a stage
which requires the feature to be mapped into the increasing
evolvement function.
In this work, we propose the use of mean color, size, color
variance, and mean gradient as chosen region features. Their
corresponding evolvement functions are defined as follows.
denote the tree node at level ;
its associLet
ated mean CIE L*a*b* color vector. For a path , the mean
is defined as cumulative color
color evolvement function
distance
(1)
where
and
is the distance between the mean colors of
and defined as
The value of
is defined as 0. The size evolvement function
is defined as
(2)
where
is the number of pixels in
is defined as
evolvement function
. The mean gradient
(3)
where
is the mean gradient in
on L* color component.
The color variance evolvement function
is defined as
(4)
where
is the average value of L*, a*, and b* variances
. As mentioned above, other custom defined evolvement
in
functions are possible as long as their values are monotonically
increasing from each leaf to the root.
Continuing to use Akiyo as an example, Fig. 2(a) shows a typ, where the cumulative
ical mean color evolvement curve
is plotted as
color distance associated with each tree node
a function of the tree level . The corresponding BPT is shown
in Fig. 2(b), where the square boxes represent the path associated with the evolvement curve. The tree has been simplified
from Fig. 1(b) using the technique described in Section IV for
visualization.
1134
IEEE TRANSACTIONS ON IMAGE PROCESSING, VOL. 16, NO. 4, APRIL 2007
A. Evolvement Function Analysis
Given an evolvement curve, instead of considering absolute
values we are interested in the rate of change at each node along
the path. This provides an indication of the willingness or reluctance of the merge occurring at a node. To obtain the rate
of change, one of the most popular choices is to calculate the
. As the tree level is discrete and unisecond derivatives of
with an interval of 1, the second
formly increases from 0 to
can be approximated by difference
derivative of
evolvement values. Equation (6) is, therefore, modified accordingly to
(7)
where
(5)
Note that
is undefined at
and
, i.e., the
first and last node in the path. As an example, Fig. 2(c) shows
the discrete second derivatives of the curve given in Fig. 2(a).
It is observed that along a path large second derivatives tend
to overshadow some of the fine details. Instead of a simple
threshold approach, special techniques are needed to detect local
depend on the particpeaks. Furthermore, the bounds of
ular image content and the chosen region feature. The graph
could be subjected to filtering but this would leave the thresholds undetermined. In order to make the framework more general and flexible, we propose the knee function [5] technique to
identify reluctant merges.
The knee function at tree level is defined as the tangent of
the acute angle between the lines defined by
and
. It is written as
(6)
where
are the slopes of the lines
and
,
,
is also undefined at
respectively. Similar to
and
. The larger value of this tangent means the more
reluctant merge occurred at the th level. Note that (6) has been
slightly modified from its original form given in [5] to allow
both positive and negative values. They are used to distinguish
the concave and convex shapes along an evolvement curve.
In an evolvement curve, the horizontal and vertical axes are
in completely different scales as the horizontal axis represents
the tree levels and the vertical axis the evolvement values based
on a chosen region feature. It is shown in Fig. 2(a) that an increment of 1 in the horizontal axis may corresponds to tens or
even hundreds increment in the vertical axis. Therefore, a proper
normalization scheme needs to be applied to the evolvement
curve before input it to the knee function. In this work, both
are indepenthe tree levels and the evolvement values
dently normalized into the range of [0, 1] for a given evolveis the number of tree levels along a
ment curve. Recall that
path . Let
denote the normalized tree levels,
the normalized
and
Fig. 2(d) shows the knee values for the evolvement curve of
Fig. 2(a). The fluctuations in the figure represent the local reluctant merges often caused by some object details. In our experience, the data normalization is an important step for the knee
function and should not be avoided.
The main advantages of using the knee function are 1) local
reluctant merges can be identified, 2) knee values can be specified in a very intuitive and comfortable way, i.e., angles which
are bounded to [0, 90], and 3) when filtering the tree, a single
predefined threshold is adequate for a chosen region feature; the
method is less sensitive to image content. If the second derivative is used, the local reluctant merges are overshadowed by the
global ones, implying this technique may be suitable for object
segmentation where small object details are less important.
This framework is suitable for the simplification of dense and
complicated trees for easy tree browsing which is presented in
the next section.
IV. TREE SIMPLIFICATION
Trees generated are often large and cluttered. This makes the
tree browsing a difficult task, and a tree simplification technique
is required. In this section, we propose a novel algorithm using
the evolvement analysis framework introduced in the previous
section.
Given a BPT, our idea is based on pruning less informative
branches, which often appear in the lower levels, from the tree.
and its sibling.
Suppose a reluctant merge occurs between
and its sibling
We consider the two subbranches rooted by
as two less informative branches. Therefore, we can prune these
two branches whilst preserving important image details of
and its sibling. If all such reluctant merges can be detected and
marked in the tree, the simplification can be done.
As the motivation of the simplification is to produce a less
dense tree for easy tree browsing, important local object details should also be preserved and available for further analysis. Therefore, we choose to use the knee function within the
framework as a means to calculate the merging reluctancy. The
pruning candidates are then selected by thresholding the knee
values along each tree path.
Given a particular tree path, it is observed that there may be
more than one knee values higher than the predefined threshold
resulting in multiple candidates for pruning. In the current
implementation, the one associated with the lowest tree level
among them is considered as the final candidate. This allows
LU et al.: BINARY PARTITION TREE ANALYSIS
1135
us to preserve as much local image details as we can and also
permits further simplification on an iterative basis. The first
if
is the smallest
salient reluctant merge is detected at
value in
for which
(8)
where is the user-supplied threshold on the angle described in
Section III. The overall algorithm is given as follows.
Suppose we have a dense and cluttered binary partition tree
and want to simplify it for easy analysis. Specify a threshold
for knee values.
1) Make an empty pool
.
Fig. 3. (a) Pepper image and (b) its associated BPT.
2) For each upward path starting from a leaf to the root node,
compute its corresponding knee function and find the node at
which the first salient reluctant merge occurs by thresholding
the knee values. Save the detected node and its sibling to the
pool and proceed to the next path.
3) Process the pool by one of the algorithms in Section IV-A
to obtain a set of new leaf nodes .
4) Remove all subbranches below the nodes in
the tree.
and re-layout
In contrast to the conservative algorithm, the output of the
bold algorithm is a set of nodes with the highest possible tree
levels in . It often results in the loss of a large amount of
image information. It is, however, useful when the tree is heavily
cluttered and one needs a quick impression of the tree. As a
by-product, it also can be used for coarse segmentation. The
method is described as follows.
1) Make an empty list .
The output of step 2) is a big pool which contains all the
nodes having the potential to be new leaf nodes. They are, however, chaotic in nature as each upward path is processed independently meaning that some candidate nodes may have either a
direct or indirect ancestor–descendant relationship. Recall that a
tree node is the aggregation of all its offsprings. To have a set of
nonoverlapping regions covering the entire image observation
area, the pool has to be processed. Two simple algorithms
are proposed in the next section, namely conservative and bold
blending algorithms.
A. Blending Algorithms
Given a tree to be simplified and a pool of potential leaf nodes
, the output of a blending algorithm is a list containing the
newly formed leaf nodes. The and must satisfy the condition that the nodes they contained cover the entire image area.
In addition, the list also needs to satisfy the nonoverlapping
condition, e.g., there is no overlapping image area between any
two nodes in .
The conservative blending algorithm preserves the maximum
information available in by constructing with the nodes
having the lowest possible tree levels in the pool. The method is
given as follows.
1) Make an empty list .
2) Assign a mask value of 0 to each node in the tree.
3) For each node in
masks to 1.
, find its direct ancestors and set their
4) For each leaf node in the tree, if its mask is 0, follow its
upward path and find the first node with a parent mask of 1.
Save this node to and set the masks of its underlying leaf
nodes to 1.
2) For each node in , find its direct ancestors. If there is no
duplicated node between its ancestors and , save this node
to .
It is interesting to note that the two blending algorithms proposed here can be considered as the modified versions of the
max and min decision rules given in [7]. The main difference is
that the max and min rules are applied to each individual path
whereas the blending algorithms have taken into account the interactions between different paths across the entire tree.
B. Experimental Results
In the following, we present some tree simplification results
by using the images obtained from the Berkeley Segmentation
Dataset (BSD) [12]. In the data set, the image size is either
321 481 or 481 321, and, hence, all have the same number
of pixels.
Fig. 3(a) and (b) shows the pepper image (image id 25098)
and its corresponding BPT, respectively. Fig. 4(a)–(d) shows
the simplified trees generated using the mean color, size, color
variance, and mean gradient evolvement, respectively. The conservative blending algorithm was employed. The corresponding
images are reconstructed from the simplified trees using the
leaf nodes and shown in Fig. 4(e)–(h). For fair comparison, the
number of leaf nodes in the simplified trees is set to 300 for
each simplification by controlling the knee threshold. It can be
seen from the figure that, even with the same number of leaf
nodes, different image content is preserved based on which region feature is used in the evolvement function. In Fig. 4(e) and
(f), the semantic meaning has been well preserved. Fig. 4(e)
which is using the color criterion has identified distinctive regions and produced well defined homogeneous descriptions of
objects within the scene, for example the individual vegetables,
1136
IEEE TRANSACTIONS ON IMAGE PROCESSING, VOL. 16, NO. 4, APRIL 2007
Fig. 4. Tree simplification applied to the BPT shown in Fig. 3(b). The conservative blending algorithm was employed. (a)–(d) Trees simplified by using the mean
color, size, color variance and mean gradient evolvement functions respectively. (e)–(h) Images composed of their corresponding leaf nodes.
price tags, and the boxes on which the vegetables are placed.
Fig. 4(f), which is using the size criterion, has similarly produced well-defined homogeneous description. However, examination of the boxes shows that small, semantically meaningless
regions have been preserved which were previously absorbed in
Fig. 4(e). This can be explained since in an upward path a small
region can meet a larger one irrespective of the color similarities, constituting a reluctant merge. Since the target number of
leaf nodes is fixed, describing homogeneous objects using a collection of regions reduces the possible granularity in other parts.
This can be seen by comparing the vegetables in Fig. 4(e) and
(f). Fig. 4(g) has been generated using the color variance criterion. It has caused simplification in the vegetables, which is
due to the low variance caused by the narrow band in the hue
histogram. Fig. 4(h) which is using the mean gradient has discarded the writing on the price tag. This is because the mean
gradients are low and similar due to homogeneity. Similar behavior is observed in the vegetables. The operator favours the
preservation of edge busy regions in proximity to homogeneous
ones, as seen in the detail preserved in the boxes.
Fig. 5 shows the simplification results generated by using the
bold blending algorithm. To be consistent, the knee thresholds
are the same as the previous experiments. The resulting trees
are considerably simpler than those for the conservative algorithm irrespective of the region features used. Only relatively
few visually dominant image areas survive. The results also suggested that a lower threshold might be more appropriate. The
bold blending algorithm may be applicable to coarse segmentation but is not suitable for the purposes of progressive tree simplification, as many semantically meaningful image details are
lost.
In Fig. 6, we show a set of tree simplifications for images:
id 16052, 97017, 172032, and 388016 [column (a)], which are
chosen to be representative of a large collection of real-world
Fig. 5. Tree simplification applied to the BPT shown in Fig. 3(b). The bold
blending algorithm was employed. (a)–(d) Trees simplified by using the mean
color, size, color variance and mean gradient evolvement functions respectively.
(e)–(h) Images composed of their corresponding leaf nodes.
images. Although it is image dependent, the number of initial regions for real-world images tends to be large and is in the order
of tens of thousands. This is shown visually in Fig. 6(b) and
in tabular form in the second column of Table I. Due to space
constraints the trees themselves are not shown, instead images
generated from the leaf nodes are presented. Fig. 6(c)–(f) shows
the simplifications based on the mean color, size, color variance,
and mean gradient evolvement using the conservative blending
algorithm. For each experiment, the target number of leaf nodes
in the simplified trees is also set to 300. Similar observations
can be made as in the previous experiment (Fig. 4) for the different region features. If the bold algorithm is used, only a few
large image areas survived due to the relatively high thresholds.
The results are less representative and not shown here due to
space constraints. A comparison of the number of leaf nodes
LU et al.: BINARY PARTITION TREE ANALYSIS
1137
Fig. 6. Four natural images and their tree simplifications. Due to space constraints, only images composed of leaf nodes are shown here: (a) shows the original
images and (b) corresponds to the original BPT; (c)–(f) are simplified by using the mean color, size, color variance, and mean gradient evolvement functions,
respectively. The conservative blending algorithm was employed.
TABLE I
COMPARISON OF THE NUMBER OF LEAF NODES BEFORE AND AFTER SIMPLIFICATION USING THE CONSERVATIVE BLENDING ALGORITHM
TABLE II
COMPARISON OF THE NUMBER OF LEAF NODES BEFORE AND AFTER SIMPLIFICATION USING THE BOLD BLENDING ALGORITHM
before and after the simplifications using the conservative and
bold algorithms can be seen in Tables I and II, respectively. Note
, where
is the
that the number of nodes in a tree is
number of leaf nodes. The output from the conservative algorithm is suitable for further processing. The bold algorithm is
an over simplification, providing a final simplified image unsuitable for further analysis but still having applications in browsing
and segmentation.
V. CONCLUSION
Pyramid image representations via the binary partition tree
are well suited for region-based image analysis providing a reduced problem space. The tree structures are used to document
the merging process of image areas. Therefore, given a tree, the
full hindsight of evolvement of image regions, from the bottom
to the top tree level, is available. Most work in the past has
concentrated on the construction of the tree, or direct examination of individual tree nodes by transversing the tree levels. The
hindsight information stored in the tree structure is not fully exploited using these techniques.
In this paper, we have developed a novel framework for
analysing tree-based image representations. It uses the hindsight stored in the tree structure and models this information by
the evolvement functions which can be defined based on some
region feature, e.g., mean color, size, color variance, or mean
gradient. The second order statistics of these functions show
1138
IEEE TRANSACTIONS ON IMAGE PROCESSING, VOL. 16, NO. 4, APRIL 2007
the reluctancy of each merge. This reluctancy suggests where
salient objects may be found. We have applied this framework
to the problem of tree simplification. For each upward path in
a tree, the node associated with the first reluctant merge, according to a chosen region feature, is considered as a candidate
for pruning and is added to a pool. The pool is then processed
by one of the two blending algorithms, the conservative and the
bold, to obtain a set of nonoverlapping new leaf nodes.
The experimental results show the algorithm is able to preserve salient image detail and maintain semantics. The conservative blending algorithm retains maximum image information
available in the pool, and, therefore, the simplified trees are
suitable for further analysis by using existing techniques [1],
[3], [4]. The bold blending algorithm, on the other hand, potentially discards image details. It is, however, useful in providing fast impressions of the tree and often results in a sensible
segmentation.
REFERENCES
[1] P. Salembier and L. Gerrido, “Binary partition tree as an efficient representation for image processing, segmentation, and information retrieval,” IEEE Trans. Image Process., vol. 9, no. 4, pp. 561–576, Apr.
2000.
[2] C. F. Bennstrom and J. R. Casas, “Object representation using color,
shape and structure criteria in a binary partition tree,” in Proc. IEEE
Int. Conf. Image Processing, 2005, vol. 3, pp. 1144–1147.
[3] C. C. Dorea, M. Pardas, and F. Marques, “A motion-based binary partition tree approach to video object segmentation,” in Proc. IEEE Int.
Conf. Image Processing, 2005, vol. 2, pp. 430–433.
[4] O. Salerno, M. Pardas, V. Vilaplana, and F. Marques, “Object recognition based on binary partition trees,” in Proc. IEEE Int. Conf. Image
Processing, 2004, vol. 2, pp. 929–932.
[5] R. C. Dubes, “How many clusters are best?—An experiment,” Pattern
Recognit., vol. 20, no. 6, pp. 645–663, 1987.
[6] E. L. A. Neto, E. Khan, J. C. Woods, and M. Ghanbari, “Description
based object tracking in region space using prior information,” Electron. Lett., vol. 39, no. 7, pp. 600–602, Apr. 2003.
[7] P. Salembier, A. Oliveras, and L. Garrido, “Anti-extensive connected
operators for image and sequence processing,” IEEE Trans. Image
Process., vol. 7, no. 4, pp. 555–570, Apr. 1998.
[8] M. Pietikainen and A. Rosenfeld, “Image segmentation by texture
using pyramid node linking,” IEEE Trans. Syst., Man, Cybern., vol.
SMC-11, no. 12, pp. 822–825, Dec. 1981.
[9] L. Vincent and P. Soille, “Watersheds in digital spaces: An efficient
algorithm based on immersion simulations,” IEEE Trans. Pattern Anal.
Mach. Intell., vol. 13, no. 6, pp. 583–598, Jun. 1991.
[10] E. L. A. Neto, J. C. Woods, H. Lu, M. Ghanbari, and I. Henning,
“Generic object registration using multiple hypotheses testing in partition trees,” in Proc. Eur. Workshop Integration of Knowledge, Semantics and Digital Media Technology, Knowledge-Based Media Analysis
for Self-Adaptive and Agile Multimedia Technology, Nov. 2004, pp.
23–30.
[11] S. Moen, “Drawing dynamic trees,” IEEE Software, vol. 7, no. 4, pp.
21–28, Jul. 1990.
[12] D. Martin, C. Fowlkes, D. Tal, and J. Malik, “A database of human segmented natural images and its application to evaluating segmentation
algorithms and measuring ecological statistics,” in Proc. 8th Int. Conf.
Computer Vision, Jul. 2001, vol. 2, pp. 416–423.
Huihai Lu was born in Xi’an, China, in 1977.
He received the B.Eng degree in mechanical and
electronic engineering from Shenzhen University,
China, in 2000, and the M.Sc. degree in microelectronic systems and telecommunications from the
University of Liverpool, Liverpool, U.K., in 2001.
He is currently pursuing the Ph.D. degree in the
Department of Electronic Systems Engineering,
University of Essex, Colchester, U.K.
His research interests include region-based image
processing, image and video segmentation, object detection and tracking, and content-based image compression.
John C. Woods (M’06) was born in a small fishing
village near Colchester, U.K., in 1964. He received
the B.Eng. (hons.) degree (first class) in 1996 and the
Ph.D. degree in 1999 from the University of Essex,
Colchester, U.K.
He has been a Lecturer in the Department of
Electronic Systems Engineering, University of
Essex, since 1999. Although his field of expertise is
image processing, he has a wide range of interests
including telecommunications, autonomous vehicles, and robotics. He is currently investigating local
positioning systems and was recently a co-signatory to a European grant examining segmentation and tracking. He is a founding member of the Gridswarm
consortium at Essex, which investigates collective and emergent behavior
within flocks and swarms. He is a Consultant to the Ngee Ann Polytechnic in
Singapore for augmented MPEG-4 over digital TV & flight systems and is the
Scientist in Residence to the local schools and colleges. He has authored more
than 50 publications over the last five years, with ten directly pertaining to this
work.
Dr. Woods is a member of the IET.
Mohammed Ghanbari (M’78–SM’97–F’01) is a
Professor of video networking in the Department
of Electronic Systems Engineering, University of
Essex, Colchester, U.K. He is best known for his
pioneering work on two-layer video coding for ATM
networks, as well as for his work on SNR scalability
in the standard video codecs, which made him an
IEEE Fellow in 2001. He has registered for 11
international patents and has published more than
350 technical papers on various aspects of video networking. He was a co-investigator on the European
MOSAIC project studying the subjective assessment of picture quality, which
resulted to ITU-R Recommendation 500. He is the coauthor of Principles
of Performance Engineering (IEE, 1997) Video Coding: An Introduction to
Standard Codecs (IEE, 1999), and Standard Codecs: image compression to
advanced video coding (IEE, 2003).
Dr. Ghanbari is a Fellow of the IEE and a Charted Engineer (CEng). He
has been an organizing member of several international conferences and
workshops. He was the General Chair of 1997 International Workshop on
Packet Video and Guest Editor of the IEEE TRANSACTIONS ON CIRCUITS AND
SYSTEMS FOR VIDEO TECHNOLOGY Special Issue on Multimedia Technology
and Applications. He served as Associate Editor for the IEEE TRANSACTIONS
ON MULTIMEDIA from 1998 to 2004 and represented the University of Essex
as one of the six U.K. academic partners in the Virtual Centre of Excellence in
Digital Broadcasting and Multimedia. He was the co-recipient of A. H. Reeves
prize for the best paper published in the 1995 Proceedings of the IEE in the
theme of digital coding and received the Rayleigh prize as the best book of the
year in 2000 by the IEE.