there is extensive current interest in the high - content , high - throughput screening of live cell populations , and the experimental techniques being developed for this purpose are leading to important biological insights with applications to new clinical therapies [ 14 ] . due to the large amount of data generated by these experiments ,
automated data processing systems for segmentation   and tracking of live cells in sequences of microscope images are a virtual necessity .
several comprehensive systems for segmentation and tracking have recently been described in the literature ( see , e.g. , [ 5 , 6 ] and references therein ) . in most existing approaches , cells are segmented using advanced level set , active contour or watershed methods , or ingenious combinations of them [ 57 ] . in this paper , we investigate the use of a multilevel aggregation algorithm as an alternative method for segmenting live cell bright field microscope images .
 saliency measure    for this algorithm to decide when aggregates of pixels constitute salient segments that should not be grouped further .
we investigate the performance of the multilevel aggregation algorithm for bright field cell segmentation in images and sequences of images , and discuss its advantages and drawbacks compared to other methods as a possible building block in comprehensive automatic cell segmentation and tracking systems . 

figure 1 shows a microscope image with approximately two dozen mouse c2c12 myoblast cells on a dark grey background .
c2c12 myoblasts ( atcc crl-1772 ) are muscle cell precursors , which have varied shape and size as well as good motility in vitro . in tissue culture , they will grow to a fully confluent monolayer with well - separated cell nuclei and a small amount of overlapping cytoplasm between adjacent cells .
our goal is to obtain separate segments for each cell in images like figure 1 .
two major challenges are , first , that the cells appear in two distinct basic shapes ( cells that are close to division show as bright circular shapes , while regular cells have more stretched shapes in which the cytoplasm and nucleus can be discerned ) , and , second , that cells may be touching or overlapping . while our ultimate goal is to automatically segment sequences of complex images like figure 1 , we start out in this paper with segmentation of simplified cases ( isolated cells and small groups of cells ) .
we use a variant of the segmentation by weighted aggregation technique [ 8 , 9 ] to segment the microscope images , which itself is based on algebraic multigrid ( amg ) methods for solving linear systems of equations [ 10 , 11 ] .
the swa method attempts to segment the image into salient ( or  prominent  ) groups of pixels by using a multilevel aggregation procedure that groups blocks of pixels at various scales , based on multiscale feature vectors for the pixel blocks .
the swa method has more recently also been used as the basis of a more general multilevel clustering algorithm [ 12 , 13 ] .
the variant of the method that we use is described in detail below , and it is explained how it is tailored to the application at hand . our algorithmic contribution is a new scale invariant 
saliency measure  for deciding when aggregates of pixels constitute salient segments that should not be grouped further .
our new saliency measure is a variant of the saliency measure employed in [ 8 , 9 ] that takes scaling into account .
furthermore , we use the so - called  first pass  of the standard amg graph coarsening algorithm [ 10 , 11 ] to coarsen the pixel graph , rather than the direct aggregation methods that are used in swa algorithms described in the literature [ 8 , 9 , 12 , 14 ] .
we test our approach on parts of real microscope images , and show how segmentation based on multilevel intensity similarity alone does not lead to satisfactory results .
however , the addition of multilevel variance of mean intensities ( as a measure of texture ) to the feature vector of each aggregate , as in [ 9 , 14 ] , leads to correct cell segmentation . in the second part of the paper ,
preliminary results are presented for applying the multilevel aggregation algorithm in space time to temporal sequences of microscope images , with the goal of obtaining space time segments ( object tunnels ) that track individual cells .
this parallels previous research results on space time segmentation using level set methods [ 15 , 16 ] and on comprehensive segmentation and tracking systems for sequences of cell images [ 5 , 6 ] , but space time segmentation using swa has , to our knowledge , not been investigated in the literature yet .
the ultimate goal of this space time segmentation is to determine a space time segment ( object tunnel ) for each individual cell , taking into account cell divisions .
ideally , when a cell divides , the segment of the mother cell should terminate and cell segments should start for the two daughter cells . in this sense , the desired outcome of our space time segmentation is more complicated than for related problems such as cerebral vasculature segmentation in ct scans , for which three - dimensional level set algorithms have been developed . also , the full space time segmentation problem is complicated since cells change shape when they divide and cells may touch and overlap . in this paper , we present preliminary results on our experience with extending the spatial swa segmentation algorithm to space time segmentation of sequences of images , for simplified cases of isolated cells and pairs of cells .
we identify problems that remain and suggest possible extensions of the algorithm that may handle them , and we comment on the potential of the swa segmentation method as a building block in comprehensive segmentation and tracking systems along the lines of [ 5 , 6 ] and references therein .
while the general ideas and concepts of the swa framework are described in several places [ 8 , 9 , 12 , 14 ] , most of the description in the literature is formulated in general terms , and not all algorithmic details are spelled out . in this paper , we want to present methods and results that are fully reproducible by the reader , and for this reason we provide a complete description of the version of the swa algorithm we settled on .
one property of the swa algorithm is that it has a significant number of parameters that have to be chosen judiciously to obtain the desired segmentation .
while this may be perceived as a potential drawback of the approach , it also opens opportunities to finetune the algorithm for the application class at hand . indeed , the problem of segmenting an image without further specifications is often ill - posed . for example , a satellite image with roads , buildings , cars and people can be segmented at the level of the roads and buildings , or at the more detailed level of individual cars and people . finetuning the swa parameters
the question about how to choose the swa parameters is not discussed much in the literature [ 8 , 9 , 12 , 14 ] , and in most cases specific parameters are not given for segmentation results that are presented as examples . again in the interest of reproducibility , we make sure in this paper to include full details about the parameters we choose for each image or image sequence for which we give segmentation results , and we also formulate some general guidelines for choosing parameters . automatic segmentation and tracking of live cells in bright field microscopy images is a difficult task [ 5 , 18 ] .
for this reason , fluorescence microscopy is often used in place of bright field microscopy to image live cells . in fluorescence microscopy
, cells are made fluorescent by applying fluorescent dyes , or by making the cells artificially express fluorescent proteins .
the strong fluorescence signals facilitate tracking , but may also have significant drawbacks . in many cases ,
the fluorescence introduced is toxic for the cells , and it may change cell behaviour . on the contrary , bright field microscopy is well suited for live cell studies as the imaging conditions can usually be chosen to minimize phototoxicity .
for example , the experiments reported in   show how the shape of a cell can be linked to genetic factors , in this case signaling proteins . in this study ,
the cells were fixed and permeabilized prior to phalloidin staining and , since the cells are no longer alive , it is impossible to examine the same cells at a later time .
however , the image segments we obtain from our analysis can be used to categorize cell shapes while keeping the cells in culture .
this ensures minimal interference with normal cell function through toxicity from photochemical effects and the high intensity illumination that is required to excite fluorescent probes .
in other types of experiments , fluorescent markers are used to measure concentrations of certain specific proteins that are under study .
a limited number of fluorescent marker channels with nonoverlapping spectra ( typically up to three ) are used in combination .
if one or two of these channels are used solely for tracking purposes , the number of channels available for measuring protein concentrations is reduced , which may be a significant limitation . for these reasons , it can be an advantage if methods can be derived that manage to track cells based on bright field images .
in addition , bright field images typically contain many features of interest , and accurate segmentation methods for bright field images are intrinsically useful since they allow the study of cell morphology and internal cell structure , and their dynamics .
for example , the morphology of a cell can be indicative of cell health or can indicate various stages of pathology .
also , accurate bright field segmentation of cells and cell organelles may allow for more precise integration of fluorescence signals over relevant parts of precisely identified cells , enhancing the accuracy of protein expression level measurements .
finally , it should also be noted that the contrast of bright field images is often enhanced by the use of phase contrast microscopy .
this allows us to see detailed structure within cells on figure 1 ( including cell nuclei and nucleoli ) , but it also generates bright halos around cells which may complicate segmentation since they do not uniformly enclose cells .
the microscope images used in this paper ( including figure 1 ) were obtained as follows .
cells were plated at a low density in glass chamber slides and imaged at 20x using a phase contrast objective ( nikon teu 2000 with cfi plan fluor elwd 20x ) and a cooled ccd camera ( hamamatsu c9100 - 12 ) .
each image contains 512 by 512 pixels , with a resolution of 0.8  m / pixel and 14 effective bits per pixel . unless otherwise noted , all cell culture reagents were purchased from invitrogen .
c2c12 myoblasts were cultivated in growth medium ( dulbecco 's modified eagle medium supplemented with 20% fetal bovine serum ( sigma ) , 2  mm glutamine , 50 units penicillin and 50  g / ml streptomycin in 10  cm cell culture plates ( corning ) .
cells were treated with 1.5  ml of 0.05% trypsin - edta for 5 minutes , manually dispersed by pipetting and diluted in growth medium to 50,000 cells / ml . subsequently , 3 ml of this suspension was added to one lab - tek   chambered coverglass well ( nunc ) and cells were allowed to settle undisturbed at 37c and 10% co2 for 16 hours .
the slide was then placed on the motorized stage of a nikon teu 2000 equipped with a solent environmental chamber where the cells were kept at the same co2 and temperature conditions as before .
, we give a brief description of the swa algorithm and introduce a new scale invariant saliency measure . in section 3
we investigate how the algorithm performs for segmenting bright field cell images . in section 4
we explain how the approach is extended to segmentation in space time in a straightforward way , and investigate the performance of space time segmentation for simple sequences of real cell images .
section 6 discusses conclusions and future work . finally , appendix a gives a pseudocode - style step - by - step description of our algorithmic implementation .
in this section , we describe the multilevel segmentation algorithm that we employ in this paper .
we start with an overview of the basic swa algorithm from [ 8 , 9 , 1214 , 21 ] , followed by a subsection on some specific more detailed aspects of the algorithm . in the third subsection ,
we propose and discuss a new scale invariant saliency measure for the swa algorithm . for a complete description of the algorithm we use
, we refer the reader to appendix a , which provides an actual pseudocode - style step - by - step description of our implementation . 

figure 2 shows a schematic representation of the swa algorithm . a high - level description of the swa algorithm proceeds as follows . in the first , top - down phase of the algorithm , pixels are recursively grouped into increasingly large overlapping blocks . at any level in the process ,
the top - down phase ends when all remaining blocks have become salient . in the second ,
bottom - up phase of the algorithm , overlapping blocks that were identified as salient are recursively sharpened , until all fine - level pixels are assigned to a unique segment at the top level .
the problem of image segmentation can be viewed in terms of segmentation of a weighted undirected graph , with each node of the graph representing a pixel , and each edge corresponding to a link between neighbouring nodes , weighted by the similarity in intensity between the two neighbouring pixels .
the swa algorithm starts with this weighted graph on the finest level ( which we call level 1 ) and forms a weighted graph of reduced size on level 2 , with the nodes of the level-2 graph representing overlapping blocks of level-1 nodes .
each level-2 block is formed around a level-1 seed point , which is called a c - point ( short for coarse point ) on level 1 .
nodes on level 1 that are not chosen as c - points are called f - points ( short for fine points ) .
the overlapping blocks are chosen such that they group neighbouring nodes that have similar intensities .
this graph coarsening can be done in a variety of ways , and the particular approach we employ is explained in the next subsection and in appendix a.3 .
this graph coarsening process is then repeated on level r , r = 2,3 , 4 ,  , to obtain the coarse - level graph on level r + 1 .
the left branch of the diagram in figure 2 shows for an example image how the nodes ( shown as red dots ) are coarsened during the first , top - down phase of the algorithm .
( for each coarse - level overlapping block , one finest - level node corresponding to the c - point of the block on the previous level is shown as a representative . ) in more specific terms , we start from the pixel graph of the original image , with the intensities of the pixels stored in level-1 intensity vector i. ( we scale each input image such that the maximum intensity value equals 1 . )
pixels that are neighbours in the horizontal or vertical directions are connected by weighted edges in the graph , with edge weights aij defined using an exponential function of the intensity difference between the pixels they connect :  
 ( 1)aij={e|iiij|if  i , j  are  neighbours,0,otherwise , 
							 with   0 a user - defined parameter .
c - points are then chosen for the level-1 graph and their indices are stored in vector c. an interpolation matrix from level 2 to level 1 is defined as  
 ( 2)pij={1if  ic ,  i = cj,0if  ic ,  icj , aicjkcaikif  ic . 
							
here we use the shorthand notation i  c to mean that i = cj for some j. each column j of p represents a level-2 node , and element pij indicates which fraction of level-1 node i belongs to level-2 block j. ( the rows of p sum to one . )
the edge weights between nodes of the level-2 graph are calculated by an averaging process   known as galerkin coarsening :  
 ( 3)a = ptap . 
							 in a similar way
, interpolation operators p are derived between the other recursive levels , and coarse - level graph weights are calculated by  
 ( 4)a[r+1]=p[r , r+1]ta[r]p[r , r+1 ] . 
  on each level , the blocks are tested for saliency : a salient ( or  prominent  ) block is a block that is sufficiently different from all the blocks it is connected to , as determined by a saliency measure .
once a block is designated salient , it is not allowed to merge with other blocks on coarser levels .
the coarsening process terminates at the level where all blocks have become salient , at which point we have found all segments in the image . in figure 2 ,
the bottommost image is at the coarsest level where coarsening stops because each of the two nodes represents a salient segment ( the white and the black segment ) .
the right branch of the diagram in figure 2 represents the second , bottom - up phase of the algorithm .
recall that the segments obtained on the coarsest level correspond to overlapping blocks on the finest level .
it is important to retain overlapping blocks in the first phase of the algorithm , since a pixel that may appear to belong primarily to a certain block according to fine - level information , may be reclassified as belonging to a different block later when coarser - level information is taken into account .
the goal of the second phase is to uniquely assign every finest - level pixel to one of the segments .
the nodes on the second - to - coarsest level are first assigned to the segments obtained on the coarsest level according to the weights in the interpolation matrix , and this is repeated recursively for nodes on increasingly fine levels . in this way , the representation of the so - far overlapping segments is obtained on each recursive level . on each level , the overlap between segments is reduced by a sharpening procedure , with a sharpening threshold d1 , which we normally take equal to 15% . in this sharpening procedure ,
nodes that belong for more than 85% to a segment are assigned for 100% to that segment , while nodes that belong for less than 15% to a segment are fully decoupled from that segment . finally , on the finest level
the swa algorithm is in many ways similar to amg methods for solving linear systems of equations [ 10 , 11 ] , and the v - shaped process of figure 2 is called a v - cycle in multigrid terminology .
contrary to the amg v - cycle , where cycles are repeated to iteratively produce better approximations to linear equations , we perform the image segmentation v - cycle only once , giving the final segmentation . 

the recursive part of the algorithm is preceded and followed by a nonrecursive part on the finest level . in the recursive part we consider two adjacent levels : level r ( the current fine level ) and level r + 1 ( the current coarse level ) . on level r
, we find a suitable subset of fine - level nodes ( the c - points ) that will form the seed points for the coarse - level blocks .
then , as long as we are not yet on the coarsest level ( i.e. , not all nodes are salient ) , we calculate the coarse - level graph weights from the fine - level weights , and coarsen again recursively .
once on the coarsest level , the recursive function returns the segments found , and performs a bottom - up process that ultimately leads to each pixel in the ( finest - level ) image being assigned to exactly one of the ( initially overlapping ) segments found on the coarsest level .
the nonrecursive and recursive parts of the algorithm are described in detail in appendices a.1 and a.2 , respectively , and the coarsening algorithm is given in appendix a.3 .
the following are further details and enhancements of the swa algorithm .    in order to coarsen the graph at the current level
, we use the so - called first pass of the standard amg coarsening algorithm [ 10 , 11 ] .
this algorithm coarsens the connectivity graph with weights aij by first dividing the connections in sets of weak and strong connections based on their weights , and then approximately determining a subset of the nodes of the graph that is a maximal independent set in the subgraph formed by only retaining the strongly connected edges .
strength parameter     ( see ( a.22 ) ) is used as a threshold to determine strong connections in the coarsening algorithm .
the nodes in the maximal independent set , which are selected such that they are not linked by strong connections , become the c - points on the current level .
nodes that have strong connections to many other nodes are more likely to be chosen as c - points . note also that , on coarse level r , nodes that have already been designated salient on previous levels ( see section 2.3 ) , automatically become c - points at the beginning of the coarsening on level r. note that we use standard amg coarsening [ 10 , 11 ] to coarsen the graph , rather than the direct aggregation methods that are used in swa algorithms described in the literature [ 8 , 9 , 12 , 14 ] .
we find the standard amg coarsening a simple and effective graph coarsening algorithm that leads to good results , as confirmed by extensive experiments .  
calculating a by 
										 ( 5)a[r+1]=p[r , r+1]ta[r]p[r , r+1 ] 
									 gives the coupling weight between two blocks based on finer - level coupling weights across their shared boundary .
however , it is beneficial to also consider the direct similarity between the blocks in terms of their average intensity .
the average intensity of each block on level r + 1 can easily be calculated from the average intensity on level r by multiplication with a scaled interpolation matrix , see ( a.11 ) and ( a.10 ) .
the coupling weights can then be rescaled as follows to incorporate similarity in average intensity : 
										 ( 6)aij[r+1]aij[r+1]e|ii[r+1]ij[r+1]| . 
									 here
, ii is the average intensity of block i on level r + 1 , and 0 is a user - defined parameter .   note that , while the diagonal terms of a do not affect the selection of c - points on level r , they do affect the off - diagonal terms of a that subsequently influence the selection of c - points on level r + 1 .
diagonal terms of a represent the internal similarity of blocks , and should be taken into account when calculating similarity between coarse - level blocks .
another blockwise quantity we use to better connect similar blocks is multilevel variance in intensity ( as a measure of texture ) .
every node on level r + 1 corresponds to an overlapping group of nodes on level r , every node on level r corresponds to an overlapping group of nodes on level r  1 , and so forth . the variance in intensity of the level - r nodes that correspond to a level - r + 1 node
is easily calculated   using the standard expression var(x ) = e((x  e(x ) ) ) = e(x )  e(x ) , see ( a.12 ) .
these variances are calculated between all consecutive levels , and are assigned to coarse - level nodes by recursive averaging ( see ( a.13 ) ) . an r - component multilevel feature vector with intensity variances
can thus be associated with every node on level r + 1 , see ( a.14 ) .   in each such feature vector ,
the last component gives the variance between the average intensities of the level - r nodes that correspond to the level - r + 1 node , the one - before - last component gives the average over those level - r nodes of the variance between the average intensities of the level - r  1 nodes that correspond to each of those level - r nodes , and so forth .
the averages in the feature vectors can be calculated efficiently via recursive averaging , see ( a.13 ) .
the coupling weights between blocks can then be rescaled according to the similarity in these variance vectors , with a scaling parameter  , see ( a.17 ) . in practice
, it turns out that variance for small blocks is less relevant and may cause incorrect segmentation .
we therefore only use variance rescaling on levels larger than level  , with  a user - defined parameter .   in order to avoid small segments ,
we only allow detection of salient segments on levels larger than level  , with  a user - defined parameter . in summary , we list the free parameters in our algorithm , to be chosen such that correct segmentation is obtained for the application at hand : top - level intensity scaling factor  , coarse - level intensity rescaling factor  , coarse - level variance rescaling factor  , coarsening strength threshold  , saliency threshold  ( see the next section ) , sharpening threshold d1 , segment detection threshold level  , and variance rescaling threshold level .   we propose a saliency measure that is a modified version of the saliency measures used in [ 8 , 9 , 1214 , 21 ] .
the saliency measures used in [ 8 , 9 , 1214 , 21 ] can be derived and motivated as follows . on each level r , define the energy functional 
 ( 7)[r](u[r])=i > jaij[r](ui[r]uj[r])2i > jaij[r]ui[r]uj[r]=u[r]tl[r]u[r](1/2)u[r]tw[r]u[r ] . 
							 here
, a is the coupling matrix on level r , the matrices l and w are given by 
 ( 8)lij[r]={aij[r]if  ij,kiaik[r]if  i = j , w[r]=a[r ] , 
							 and u is a boolean state vector   for a particular block on level r such that uj = 1 if node j belongs to the block and uj = 0 otherwise .
l is called the laplacian of the ( weighted ) graph .   note that w = a on all levels
so there is no real need to introduce the variables w , but below we choose to use the w in expressions for the saliency measure .  
the swa algorithm seeks segments ( boolean vectors u ) that yield low values of the energy functional .
on the finest level , this formulation is equivalent to a normalized cut formulation for the segmentation problem [ 14 , 22 ] .   in the normalized cut approach ,
a generalized eigenvalue problem is formulated on the finest level that is related to functional ( 7 ) .  
the few eigenvectors with lowest eigenvalues are computed and are used to segment the image using a clustering method .
note that amg solvers can also be developed that directly calculate the eigenvectors of this fine - level eigenvalue problem in an efficient manner .   in the swa approach ,
however , we do not directly calculate the fine - level eigenvectors , but , instead , consider increasingly coarse versions of the coupling matrix and detect salient segments based on connection strength in those coarse - level coupling matrices , guided by functional ( 7 ) .  
this approach allows us to take into account coarse - level features ( like multilevel variance ) for segment detection . at level r , the swa algorithm checks for each node i whether it is salient .
( recall that node i is interpreted as an overlapping block of finest - level pixels . ) to this end , define the boolean vector for the single - node segment with node i on level r by uj = ij ( i.e. , ui = 1 , and uj = 0 for j  i ) .
the saliency measure i of node i is then given by 
 ( 9)i[r]=(u[r],i)=lii[r](1/2)wii[r ] , 
							 and node i is designated a salient segment if its saliency measure is smaller than a user - defined constant  : 
 ( 10)i[r]<. 
							 ( note that saliency measure ( 9 ) can not be used on the finest level , since wii = 0 for all finest - level nodes i. in practice , this is normally resolved by not allowing salient nodes on the finest level . )
it can be understood easily that saliency measure ( 9 ) is sensitive to the scales of segments , and , depending on the application , this may lead to difficulties . in what follows , we illustrate the scale sensitivity of saliency measure ( 9 ) by a simple example , and propose a new variant of saliency measure ( 9 ) that takes into account scaling .
saliency measure ( 9 ) for node i on level r can be related to the block of pixels on the finest levels that corresponds to node i ( which we can call block i ) .
indeed , the saliency measure can be interpreted as the sum of the coupling coefficients along the border of block i divided by the sum of the coupling coefficients along connections internal to block i .  
it can easily be seen that this interpretation is exact for any nonoverlapping block , as is illustrated by the following simple example .
consider figure 4 which represents an example image with a square block of white pixels in the centre , and assume that this block corresponds to node i on level 2 in the aggregation process ( we thus call it block i ) .
the ith column of the interpolation matrix between levels 2 and 1 , p , contains 1  s in the rows corresponding to the pixels in block i , and 0  s in the other rows .
it is convenient to represent the ith column of p in so - called stencil form , as 
 ( 11)pi=. 
							 let us define two more matrices ,   the adjacency matrix v and   the unweighted graph laplacian g , which are boolean versions of w and l , not weighted by the coupling strengths in a : 
 ( 12)vij={0if  aij=0,1if  aij0,gij={vijif  ij,kivikif  i = j . 
							
the stencils of the operators v and g are given by  
 ( 13)v=,g=[11411 ] . 
							
( note that these stencils represent the nonzero elements in each of the columns ( or rows ) of v and g. since each column has the same pattern of nonzeros , we don not give the stencils of v and g a subscript index .
note that columns corresponding to pixels close to the boundaries of the image would have a different nonzero pattern , but we assume that the white block in figure 4 is embedded in a larger black image and is located far from the image boundary , such that we don not have to worry about boundaries . )
let us now calculate the ith diagonal elements of the level-2 versions of v and g , namely , v = pvp and g = pgp .
first , we want to show that diagonal element gii = pigpi equals the boundary length of block i , which in this example is 3  4 = 12 . applying matrix g to column pi gives , in stencil notation ,  
 ( 14)gpi=[0111012221110111212101110 ] . 
							 multiplying this with row pi
results in a scalar value of  
 ( 15)pitgpi=12 , 
							 which is the boundary length of block i , as desired .
next we want to show that ( 1/2)vii = ( 1/2 )  pivpi equals the number of internal connections within block i. first apply matrix v to column pi to get , in stencil notation ,  
 ( 16)vpi=. 
   then multiply this with row pi to obtain  
 ( 17)pitvpi=24 , 
							 which equals twice the number of internal connections , or approximately twice the area of block i. due to this interpretation of the diagonal elements of matrices g and v in terms of block boundary length and block area , we will in what follows refer to the matrices g as boundary length matrices , and to v as area matrices .
it is now easy to see that the ith diagonal element of l corresponds to the sum of the coupling coefficients along the boundary of block i , or , in other words , to the boundary length of block i weighted by the similarity with neighbouring blocks along the block boundary .
similarly , the ith diagonal element of w = a corresponds to twice the sum of the coupling coefficients along connections internal to block i , or , in other words , to twice the area of block i , weighted by the mutual similarity of neighbouring finer - level blocks in the interior of block i. we therefore call the matrices w weighted area matrices .
note that this interpretation also follows directly from plugging u = pi into ( 7 ) ( middle expression ) . with these interpretations of the diagonal elements of l , w , g and v in hand
, we can now analyze the scale behaviour of saliency measure ( 9 ) , and propose a new scale invariant version of it .
figure 5 shows two examples of images with a white shape on a black background .
the original saliency measure 
 ( 18)i[r]=lii[r](1/2)wii[r ] , 
							 is much smaller for shape ( a ) than for shape ( b ) : shape ( a ) has a shorter boundary and a larger area than shape ( b ) , and the similarity - weighted boundary length lii is proportional to the block boundary length , while the similarity - weighted area ( 1/2)wii is proportional to the area .
for the example considered , this is undesirable , since both shapes should be deemed equally salient : their saliency measure should be of similar value for the swa algorithm to segment them correctly if they were to occur together in a larger image .
it is also clear that saliency measure ( 18 ) tends to assume geometrically smaller values as levels get coarser , since , in two dimensions for example , shape areas normally grow by a factor of four when boundary lengths double .
consider two white blobs with the shape of figure 5(a ) , a large one and a small one .
the large blob would reduce to a single node at a coarser level than the small blob , and the salience measure ( 18 ) for the large blob would be smaller than for the small blob , since the ratio of boundary length to area is smaller for the large blob than for the small blob .
we can thus say that saliency measure ( 18 ) is not scale invariant ( and also not shape - invariant , according to the example of figure 5 ) .
potential scaling difficulties with saliency measure ( 18 ) have been discussed in the literature and some ad hoc fixes have been proposed , but a generally applicable modification that addresses these scaling issues has not been proposed yet . in order to remedy the potential scaling difficulties of saliency measure ( 18 ) , we propose the following new saliency measure : 
 ( 19)i[r]=lii[r]/gii[r]wii[r]/vii[r ] . 
							
the motivation behind this new saliency measure is simple : we normalize the similarity - weighted boundary length by dividing it by the unweighted boundary length , and we normalize the similarity - weighted area by dividing it by the unweighted area . as a consequence ,
the quantities lii / gii and wii / vii become scale invariant ( they lie between 0 and 1 , since all coupling weights also lie between 0 and 1 ) .
the new saliency measure can then simply be interpreted as 
 ( 20)i[r]=average  similarity  along  boundary  of  block  iaverage  similarity  in  interior  of  block  i. 
							 this interpretation also provides an easy intuitive understanding of the saliency measure : a block is salient if it has low average similarity to its neighbouring blocks , but this has to be evaluated relative to how similar its own finer - level blocks are to each other .
it is also clear that the new saliency measure may make it easier for many applications to choose a saliency threshold  below which nodes are to be considered salient : due to the scale invariance ( and shape - invariance ) of the new measure the saliency threshold can remain constant on all levels , and segments with different shapes can be detected more consistently .
we have experimented extensively comparing the scale invariant saliency measure ( 19 ) and the original saliency measure ( 18 ) . even though the scale invariant saliency measure is somewhat more expensive to compute ( a second three - way sparse matrix product v = pvp has to be evaluated on each level )
, we have found that it is much easier for our application to find a suitable value of the saliency threshold  that works well on all recursive levels and for the different shapes the cells in our images assume . for our application
, the extra work leads to a significantly more robust , less parameter - dependent algorithm and is thus worthwhile .
it has to be noted , though , that for some applications the original saliency measure ( 18 ) may give good results ( with less work ) , or may be preferable for other reasons .
the original saliency measure is expected to work well for segments of similar size and shape . also , the original saliency measure favours large segments ( since the saliency measure tends to assume smaller values on coarser levels ) , and this may be beneficial in applications in which only large segments are of interest .
( e.g. , one could consider an image with many white blobs of different sizes on a black background , and if only the large blobs are important , the original saliency measure can be used to select them . ) to finalize this section on a scale invariant saliency measure , we want to make three remarks .
first , the example in figure 4 that led to the interpretations of lii , gii , wii and vii in terms of block boundary lengths and areas , was set in the context of nonoverlapping blocks . in the first stage of the swa v - cycle ,
the interpretation in terms of block boundaries and areas becomes less straightforward in this case and the heuristics become approximate , but the formulas remain well posed and extensive testing indicates that the measure performs as expected for the case of overlapping blocks as well .
second , saliency measure ( 19 ) is not defined on the finest level since wii = 0 and vii = 0 for all finest - level nodes i. in many applications , salient segments on the finest level are not of interest , and can be disallowed .
if they are to be allowed , the areas of finest - level pixels can be set to one , and scale invariant saliency measure i = lii / gii can be used .
third , scale invariant saliency measure ( 19 ) only uses the diagonal elements of the boundary length and area matrices l , g , w and v , and the off - diagonal information in these matrices remains unused .
the off - diagonal elements of these matrices can be used to refine ( 19 ) .
for example , if block i shares a very short boundary with block j to which it is very similar , but is very different from all other neighbouring blocks , then its average similarity along the boundary , lii / gii , may be very small , even though block i is very similar to one of its neighbours . in this case
, it may be desirable not to designate block i as salient , and to aggregate it with block j. such a situation can be detected by comparing the sizes of lij / gij for all neighbours j of i ( these ratios of off - diagonal elements can be interpreted as average similarities between blocks along their mutual boundary ) , and block i may only be considered salient if all of these are small ( relative to block i 's internal similarity ) .
improvements of this kind may be important for certain types of applications , and remain a topic of further research .
in this section we evaluate the performance of the multilevel segmentation algorithm by applying it to bright field phase contrast cell microscopy images .
first we demonstrate the advantage of segmenting taking the multilevel intensity variance into account , versus not taking it into account .
the image of figure 6(a ) has two regions that differ in texture but are identical in average intensity . using only intensity ,
only one segment is found ( figure 6(b ) ) because the algorithm can not distinguish the patterned shape from the uniform background . however , when intensity variance is incorporated , the two segments are identified separately ( figure 6(c ) ) .
( all cell images in this and the next section are obtained by cutting out a square n  n region from larger 512 by 512 images as in figure 1 . )
however , correct segmentation is obtained : the variance of the background is low , but cells have high internal variance . by preferentially grouping blocks with high variance and blocks with low variance , cell parts are forced to merge together rather than merge with the background .
figures 8 , 9 and 10 show further examples of successful segmentation results for increasingly difficult cases of cells with elongated expansions , touching cells , and cells that are close to division ( bright and circular ) .
note that the segmentation parameters employed differ somewhat between the examples ; parameter selection is discussed at the end of this section .
also , if the background is not contiguous , the swa algorithm finds a segment for each of the separate background regions .
these background segments can easily be grouped together since they have very similar feature vectors at the level where they are detected as salient segments .
finally , figure 11 shows segmentation results for a more difficult example involving four whole cells at once , one of which is close to division . with one choice of parameters ,
we get figure 11(b ) , which correctly identifies the 2 cells at the bottom with sharper boundaries but does not segment the top 2 cells correctly . with another choice of parameters , we get figure 11(c ) , where all four cells are found .
however , part of the top - right cell is segmented with the background , and the nucleus of the bottom cell has its own segment .
the results of figures 710 demonstrate that the swa algorithm is capable of correctly segmenting bright field cell images of moderate complexity .
first , it is undesirable that parameters have to be changed depending on the image , since we are pursuing an automatic method .
( the next subsection explains how we have chosen the parameters for our algorithm to obtain the results shown above .
) however , the goal of the swa approach is to include enough multilevel features in   the feature vectors of the overlapping blocks on the various levels to allow the algorithm to find correct segments for all images in a certain class , for example , the bright field cell images obtained by our experiment , with a single set of parameters .
if this is achieved , the free parameters of the method are not a drawback , but are actually used to finetune the algorithm for the application class at hand , steering the segmentation in the desired direction . in our current implementation we have included multilevel intensity and multilevel intensity variance , and have shown that this allows the algorithm to correctly segment relatively complex bright field cell images . since these images are difficult to segment , this is a significant achievement , even if somewhat different parameters are required for different images .
note also that the multilevel information about the segments gained by the swa algorithm leads to several other advantages over commonly used segmentation methods , as discussed in section 6 .
however , it is clear that further research is needed before a fully automatic reliable swa segmentation method is obtained for the bright field images under consideration .
a first type of improvement can be offered by including more features in the feature vector .
for example , geometrical shape moments can be calculated for overlapping blocks at all levels , giving information about block shape and orientation that can be used to preferentially group together blocks that have similar shape or orientation [ 9 , 14 ] .
we expect that this can be used to deal better with the difference between cells that are close to division ( they appear bright and circular ) and regular cells .
the algorithm performs well on bright field images containing few cells , but the quality of the segmentation deteriorates when more cells are present .
this is mainly due to the low - contrast boundaries and the broken halos that surround the cells .
one way to overcome this problem may be to detect and promote boundary integrity across neighbouring aggregates as in .
a second type of improvement , however , may be achieved by simply considering the extra information that is present in temporal sequences of images .
the swa algorithm can take immediate advantage of this information by applying it directly to these image sequences in space time .
however , before exploring swa segmentation in space time in section 4 , we first discuss how we chose the parameters for the segmentation results of figures 711 .
to apply the algorithm to an image , we need to choose values for segmentation parameters  ,  ,  ,  ,  , d1 ,  and . in order to find suitable parameters , we normally start with an initial parameter choice , and then finetune individual parameters according to the following guidelines . a suitable initial parameter set for our types of images
to increase the contrast level of the image , increase top - level intensity scaling factor  , which amplifies the intensity difference between pixel pairs .   for images containing broad bright or dark boundaries of regions ( such as the halos in the bright field cell images ) , we do not want these boundaries to become salient segments themselves .
since a large coarse - level intensity rescaling factor  causes blocks with high average intensity to become more disconnected from their neighbours , a bright block can very easily become a salient segment . to avoid this , decrease  to a small value ,
say in the range .   in order to separate desired segments that differ more in average intensity and less in intensity variance ,
choose a larger intensity rescaling factor  and a smaller variance rescaling factor . do the opposite if the desired segments differ more in variance .  
if the algorithm finds too many ( small ) segments , try   
 decreasing  ( more strong connections ) , decreasing  ( stricter saliency threshold ) , increasing  ( segments allowed only on coarser levels ) . 
  decreasing  ( more strong connections ) ,   decreasing  ( stricter saliency threshold ) ,   increasing  ( segments allowed only on coarser levels ) . on the contrary , if too few ( large ) segments are found , then shift the parameter values in the opposite direction   the process for segmenting image sequences in space time ( see next section ) is similar but we usually start with a smaller  , such as 0.03 .
this is so because a node in an image sequence typically has more neighbours than a node in a single image .
if we used the same  , there would be fewer strong connections since our strength criterion defines strength relative to row sums of the coupling matrix ( see ( a.22 ) ) .
in this section we describe results obtained when applying the multilevel swa algorithm to sequences of images . in our experimental technique
cell trajectories in space time thus form  object tunnels  that are found efficiently by the swa algorithm .
the extra temporal information makes it easier to resolve difficult cases such as touching cells , dividing cells , and cells that temporarily overlap .
the resulting space time segments can also be used for tracking cell motion . by stacking up the images , the problem of segmenting multiple images
it is not difficult to modify the swa algorithm to suit a 3d problem because the algorithm is already designed to coarsen arbitrary graphs , which can represent geometric grids of any dimension .
additionally , swa can easily be applied to datasets with three spatial dimensions and one temporal dimension with little or no modicfication .
figure 12 shows a cell with an irregular shape moving from the top - left corner of the window to the bottom - right corner , while slightly changing its shape , from image t = 1 to image t = 9 .
applying the swa algorithm with appropriately chosen parameters to this stack of images , we find the two segments shown in figure 13 .
note that the cell boundary is quite accurately captured in every frame , even though the boundary of the cell is irregular . 

figure 14 shows a plot of this result in 3d with the red tube representing the cell wall . in figure 14(a ) , the images are stacked with the t = 1 slice on top . in figure 14(b ) , the stack is reversed to show the t = 9 slice on top .
the next set of images ( figure 15 ) shows a slow - moving triangular cell , and figure 16 shows cell contours annotated by a human expert .
figure 17 shows the swa segmentation results , and figure 18 gives a 3d representation of them . in comparison with the human expert ,
the swa algorithm segments 71634 out of the 121  121  5 = 73205 pixels correctly , yielding a 97.85% accuracy . 

figure 19 shows a sequence of 11 cell images which represent a cell dividing into two cells . in figure 20 ,
this may be useful if one desires one large connected segment for all cells in a tree - like structure .
figure 22 shows that segmentation parameters can be modified to obtain two segments , one for each of the daughter cells .
even though the first few images contain only one cell , the information from later times causes the algorithm to interpret the mother cell as two cells that are about to separate . having two segments instead of one large segment for all three cells may be useful if one desires separate segments for each unique cell .
in fact , if earlier images were included , one would want a third segment for the mother cell in this case .
these two results illustrate how a judicious choice of segmentation parameters allow the user of the swa algorithm to steer the segmentation process towards the outcome that is desirable for the application at hand
. figures 21 and 23 show 3d trajectories for the two segmentations . while more research is clearly needed to handle these rather complex cell divisions properly , the preliminary results shown point to interesting possibilities to use the space time swa algorithm as a building block of comprehensive tracking systems .
multilevel algorithms often enjoy the desirable properties of fast execution time and low memory cost that are linearly proportional to the number of data elements [ 911 ] . in this section ,
we demonstrate how we achieved linear runtime as a function of the number of pixels in the input image for our implementation of the swa algorithm .
we show that this , as expected , also holds for the space time version of the algorithm .
this makes the space time swa algorithm a highly attractive building block for segmentation and tracking systems applied to long sequences of high - resolution images .
also , if applications were to arise in which image sequences with very large numbers of pixels have to be segmented in short time , efficient parallel versions of the swa algorithm could be developed , along the lines of successful parallel implementations of amg , which have been shown to scale well on large parallel computers ( see , e.g. , , and references therein ) .
we test runtime scaling by fixing a set of segmentation parameters and running the algorithm on images of different resolution , from 512  512 to 10  10 .
( we do this using an original 512  512 image that is downsampled to increasingly lower resolution . ) for each resolution , we determine the typical runtime by calculating the average runtime over three trials .
figure 24 shows that the runtime scales almost linearly as a function of the number of pixels .
our implementation is a mixed matlab - c research code , taking advantage of matlab 's sparse matrix data structures and operations , and employing c for the compute - intensive parts of the code that can not easily be done efficiently in matlab ( in particular , the amg coarsening step ) .
this implementation could obviously be accelerated significantly for a production environment by migrating the whole implementation to c. however , even in our mixed matlab - c implementation , we obtain almost linear scaling , and a quite reasonable runtime of approximately 14 seconds for segmenting a 512  512 image . figure 25 shows that we also obtain linear runtime for a 3d 512  512  5 image downsampled to increasingly lower resolution .
in this paper , we have investigated the use of a multilevel aggregation algorithm as a method for segmenting live cell bright field microscope images .
we use a variant of the segmentation by weighted aggregation ( swa ) technique [ 8 , 9 ] and incorporate an improved scale invariant saliency measure , which can identify salient segments more accurately .
we have shown that bright field cell images of moderate complexity are segmented correctly by incorporating multilevel intensity and intensity variance .
we have shown how the swa algorithm can be applied without significant modification to temporal sequences of images , producing segments that track cell contours in space and time .
correct segmentation still depends on a judicious choice of segmentation parameters , and further research is needed before a fully automatic reliable swa segmentation method is obtained for the bright field images under consideration . in future work , we plan to investigate improving segmentation results by including more features in the feature vector .
for example , we are considering to include shape moments , anisotropic texture , cross - correlation between features , and boundary detection [ 9 , 14 , 21 ] .
we also plan to apply the multilevel aggregation algorithm to segmentation of cell parts ( cytoplasm , nucleus and nucleoli ) .
while the robust application of multilevel aggregation to bright field cell images requires further research , it is already clear that the swa segmentation approach may have several advantages over more commonly used segmentation techniques , which include level set , active contour , and watershed methods .
first of all , multilevel aggregation is fast and linearly scalable in the number of pixels to be segmented .
the algorithm is conceptually simple since there is no need to define initial level set seeds , or extract markers as in watershed .
the space time segmentation approach uses extra temporal information that makes it easier to resolve difficult cases like touching cells , dividing cells and cells that temporarily overlap .
nevertheless , it seems that extensive further research is required to handle these difficulties properly .
the feature vector for each resulting segment contains multilevel information about the segment that can be exploited in various ways .
it can be used to classify segments as background , dividing cell , or regular cell , and it can potentially be used ( in 3d ) to separate tracks of dividing cells from tracks of regular cells , to aid the proper handling of cell division events .
the multilevel segmentation approach provides a single , unified technique that produces accurate cell trajectory segments ( for moderately complex cases so far ) and gives a lot of additional useful information .
it is clear that it will have to be combined with other advanced methods of geometric , modeling and statistical nature in order to obtain a complete and robust segmentation and tracking system , along the lines of the sophisticated and comprehensive segmentation and tracking methods that recently have been described ( see [ 5 , 6 ] and references therein ) .
however , due to its conceptual simplicity , linear efficiency , and tunability , and due to the useful additional multilevel information it provides , multilevel aggregation may simplify the development of such comprehensive systems , and it thus promises to be an attractive alternative to level set , active contour and watershed approaches as a basic building block for robust segmentation and tracking systems .
output : an n  m boolean segmentation matrix u describing m segments ( uij = 1 means that pixel i belongs to the jth segment ) .
define global segmentation parameters :   

  ( top - level intensity scaling factor ) , 
  ( coarse - level intensity rescaling factor ) , 
  ( coarse - level variance rescaling factor ) , 
  ( coarsening strength threshold ) , 
  ( saliency threshold ) , 
 d1 ( sharpening threshold ) , 
  ( segment detection threshold level ) , 
  ( variance rescaling threshold level ) . 
 

 ( top - level intensity scaling factor ) , 
  ( coarse - level intensity rescaling factor ) , 
  ( coarse - level variance rescaling factor ) ,  
  ( coarsening strength threshold ) , 
  ( saliency threshold ) , 
 d1 ( sharpening threshold ) , 
  ( segment detection threshold level ) , 
  ( variance rescaling threshold level ) .
initialize level 1 variables  , m , i , a , s , l , g , v and  :   
 current level  = 1 .
, m}. let i be an m  1 vector with ij as the intensity of pixel j , where the intensity values may range from 0 to 1 .
( each input image is scaled such that the maximum intensity value equals 1 . )
let coupling matrix a be an m  m matrix with 
															 ( a.1)aij={e|iiij|if  i , j  are  horizontal  orvertical  neighbours,0,otherwise.let variance matrix s be an m  m zero matrix .
let weighted boundary length matrix l be an m  m matrix with 
															 ( a.2)lij={aijif  ij,kiaikif  i = j.let area matrix v be an m  m matrix with 
															 ( a.3)vij={0if  aij=0,1if  aij0.let boundary length matrix g , be an m  m matrix with 
															 ( a.4)gij={vijif  ij,kivikif  i = j.let saliency vector  be an m  1 vector with 
															 ( a.5)i = liigii . 
 
, m}. let i be an m  1 vector with ij as the intensity of pixel j , where the intensity values may range from 0 to 1 .
( each input image is scaled such that the maximum intensity value equals 1 . )  
let coupling matrix a be an m  m matrix with 
															 ( a.1)aij={e|iiij|if  i , j  are  horizontal  orvertical  neighbours,0,otherwise .
let weighted boundary length matrix l be an m  m matrix with 
															 ( a.2)lij={aijif  ij,kiaikif  i = j . let area matrix v be an m  m matrix with 
															 ( a.3)vij={0if  aij=0,1if  aij0 .
let boundary length matrix g , be an m  m matrix with 
															 ( a.4)gij={vijif  ij,kivikif  i = j . let saliency vector  be an m  1 vector with 
															 ( a.5)i = liigii .
determine overlapping segments by calling the recursive graph segmentation function : 
												 ( a.6)u = imagevcycle(,m , i , a , s , v, ) . 
											
assign pixels uniquely to segments : set 
												 ( a.7)uij{1if  j = min  { j : max  k  uik = uij},0,otherwise . 

input :  , m , i , a , s , v , . output : u , in which uij indicates the fraction of node i on level r belonging to segment j. if      , set all i = . ( no salient segments allowed on current level . )  
coarsen the current graph : set 
												 ( a.8)c[r]=coarsenamg(a[r],[r],, ) , 
											 where coarsenamg is a function described in appendix a.3 .  
let m be the length of c - point vector c.   if m = m ( no further coarsening obtained ) , output u as an m  m identity matrix ( every current node is a segment )
let interpolation matrix p be an m  m matrix with 
												 ( a.9)pij[r , r+1]={1if  ic[r ] ,  i = cj[r],0if  ic[r ] ,  icj[r],aicj[r]kc[r]aikif  ic[r ] .
let column - scaled interpolation matrix p[r , r+1 ] be an m  m matrix with 
												 ( a.10)pij[r , r+1]=pij[r , r+1]kpkj[r , r+1 ] .
let coarse - level intensity vector i be an m  1 vector with 
												 ( a.11)i[r+1]=(pij[r , r+1])ti[r ] .
for each block on the current coarse level , r + 1 , compute a new intensity variance measure relative to level r : 
												 ( a.12)scoarse[r+1]=(p[r , r+1])t(i[r])2(i[r+1])2 , 
											 and average the previously calculated variance measures for levels finer than level r + 1 : 
												 ( a.13)sfine[r+1]=(p[r , r+1])ts[r ]
. 
											 here , ( i ) and ( i ) are the vectors i and i squared componentwise .
then coarse - level intensity variance matrix s is an m  ( r + 1 ) matrix given by 
												 ( a.14)s[r+1]=[sfine[r+1 ]    scoarse[r+1 ] ] .
define coarse - level coupling matrix a , an m  m matrix , in three steps .  

let 
															 ( a.15)a[r+1]=p[r , r+1]ta[r]p[r , r+1].rescale using coarse - level intensity : 
															 ( a.16)aij[r+1]aij[r+1]e|ii[r+1]ij[r+1]|  i , j.if    , rescale using multilevel variance : set , for all i , j , 
															 ( a.17)aij[r+1]aij[r+1]e||si[r+1]sj[r+1]||2 , 
														 where si is the ith row of coarse - level intensity variance matrix s. 
  let 
															 ( a.15)a[r+1]=p[r , r+1]ta[r]p[r , r+1 ] .
if    , rescale using multilevel variance : set , for all i , j , 
															 ( a.17)aij[r+1]aij[r+1]e||si[r+1]sj[r+1]||2 , 
														 where si is the ith row of coarse - level intensity variance matrix s.   let coarse - level weighted area matrix w = a.   let coarse - level area matrix v = pvp .
define coarse - level weighted boundary length matrix l , an m  m matrix , in two steps :  
 let l = a . 

l 
 ii 
												   kilik for all i. 
 
 l 
 ii 
												   kilik for all i.   define coarse - level boundary length matrix g , an m  m matrix , in two steps :  
 let g = v . 

g 
 ii 
												   kigik for all i. 
 
 g 
 ii 
												   kigik for all i.   let coarse - level saliency vector  be an m  1 vector , determined as follows .
for each c - point i , if it was salient on level r , keep it salient on level r + 1 . if not , determine its saliency using the saliency measure .   if   ci = 0 , then i = 0 ,   otherwise 
										 ( a.18)i[r+1]={lii[r+1]/gii[r+1]wii[r+1]/vii[r+1]if  lii[r+1 ]  /gii[r+1]wii[r+1]/vii[r+1]>0otherwise .
recursively segment the coarse graph : let 
												 ( a.19)u[r+1]=imagevcycle([r+1],m[r+1],i[r+1],a[r+1 ] ,  s[r+1],v[r+1],[r+1 ] ) .
find the current segmentation matrix from the coarse - level segmentation matrix : let 
												 ( a.20)u[r]=p[r , r+1]u[r+1 ] . sharpen overlapping segments : for all i , j , set 
												 ( a.21)uij[r]{0if  uij[r]<d1,1if  uij[r]>1d1,uij[r]otherwise return current segmentation matrix u.  
							  input : a ,  ,  , . output : c , indices of c - points chosen on level r. let m be the number of rows ( or columns ) in a.   let a be an m  m matrix containing only strong connections .
( one may also use the criterion aij    max  kiaik for strong connections , which is more standard in the amg context . in our experience , either criterion may be used , but  may have to be chosen differently . )  
let  be an m  1 vector in which i denotes the number of nonzero entries in column i of a[r ] .  
let t be an m  1 zero vector that keeps track of the set to which each node is assigned . for node i ,
ti = 0 means it is unassigned , ti = 1 means it is a c - point , and ti = 2 means it is an f - point .   for i = 1,2 , 
, m , if i <  , then set ti  1 and i  0 .
( so that salient nodes , or segments , are designated as c - points . )   while not all ti > 0 , do the following .  

let j be the smallest value satisfying tj = 0 and j = max  kk .
( nodes that strongly influence many other nodes are likely to be chosen as c - points . ) set tj  1 and j  0 .
let k={k : akj[r]>0,tk=0}. ( k is the set of unassigned nodes that are strongly influenced by node j. ) for all k  k , do the following
let h={h : akh[r]>0,th=0}. ( h is the set of nodes that strongly influence k. ) for all h  h , set h = h + 1 .
( nodes in h are made more likely to become c - points . ) 

 
let j be the smallest value satisfying tj = 0 and j = max  kk .
( nodes that strongly influence many other nodes are likely to be chosen as c - points . )   set tj  1 and j  0 .  
let k={k : akj[r]>0,tk=0}. ( k is the set of unassigned nodes that are strongly influenced by node j. )   for all k  k , do the following .  
 set tk  2 and k  0 .
let h={h : akh[r]>0,th=0}. ( h is the set of nodes that strongly influence k. ) for all h  h , set h = h + 1 .
( nodes in h are made more likely to become c - points . ) 
 
let h={h : akh[r]>0,th=0}. ( h is the set of nodes that strongly influence k. )   for all h  h , set h = h + 1 .
( nodes in h are made more likely to become c - points . )  
let the vector of c - points be c = { i : ti = 1}.   let k be the number of consecutive images we wish to segment in space time .
the following modifications need to be made to the nonrecursive part of the algorithm ( appendix a.1 ) .
to highlight the changes , we do not rewrite any steps that do not change .
read in the k greyscale images as n  n intensity matrices , i1 , i2 ,  , ik .
let n = n.   ( the global segmentation parameters are defined as before . )   initialize variables  , m , i , a , s , l , g , w , v and  :  
 set the current number of nodes m = nk . obtain the m
 1 intensity vector i by reshaping the n  nk intensity matrix given by 
															 ( a.23)[i1i2ik1ik ] . 
 a 
												  is an m  m matrix with 
															 ( a.24)aij={e|iiij|if  i , j  are  horizontal ,  verticalor  time - wise  neighbours,0,otherwise.the other variables are defined as before . 
 
set the current number of nodes m = nk .   obtain the m  1 intensity vector i by reshaping the n  nk intensity matrix given by 
															 ( a.23)[i1i2ik1ik ] . 
 a 
												  is an m  m matrix with 
															 ( a.24)aij={e|iiij|if  i , j  are  horizontal ,  verticalor  time - wise  neighbours,0,otherwise .
everything else in the algorithm , including the recursive part and the coarsening , remains unchanged .
 a multilevel aggregation method is applied to the problem of segmenting live cell bright field 
 microscope images . 
 the method employed is a variant of the so - called  segmentation by weighted 
 aggregation  technique , which itself is based on algebraic multigrid methods . 
 the variant of the 
 method used is described in detail , and it is explained how it is tailored to the application at hand . 
 
 in particular , a new scale - invariant  saliency measure  is proposed for deciding when aggregates of 
 pixels constitute salient segments that should not be grouped further . 
 it is shown how segmentation 
 based on multilevel intensity similarity alone does not lead to satisfactory results for bright field cells . 
 
 however , the addition of multilevel intensity variance ( as a measure of texture ) to the feature vector 
 of each aggregate leads to correct cell segmentation . 
 preliminary results are presented for applying 
 the multilevel aggregation algorithm in space time to temporal sequences of microscope images , 
 with the goal of obtaining space - time segments (  object tunnels  ) that track individual cells . 
 the 
 advantages and drawbacks of the space - time aggregation approach for segmentation and tracking 
 of live cells in sequences of bright field microscope images are presented , along with a discussion 
 on how this approach may be used in the future work as a building block in a complete and robust 
 segmentation and tracking system . 
1. Introduction
2. Algorithm Description
3. Segmentation Results
4. Space Time Segmentation and Tracking
5. Scalability
6. Conclusions and Future Work
A. Detailed Description of Multilevel  Segmentation Algorithm