propagate              package:EBImage              R Documentation

_V_o_r_o_n_o_i-_b_a_s_e_d _s_e_g_m_e_n_t_a_t_i_o_n _o_n _i_m_a_g_e _m_a_n_i_f_o_l_d_s

_D_e_s_c_r_i_p_t_i_o_n:

     R implementation of the Voronoi-based image segmentation on image
     manifolds [2].

_U_s_a_g_e:


         # S4 Method for Image-class

         propagate(x, seeds, mask=NULL, lambda=0.005, ext=1)


_A_r_g_u_m_e_n_t_s:


     '_x' An object of 'Image-class' to be segmented, in the 'Grayscale'
          mode. 

     '_s_e_e_d_s' An object of 'Image-class' of the same size as x in all
          three dimensions; in the 'Grayscale' mode with integer-based
          object encoding, as returned by 'watershed'. This image
          provides seed points for object detection. 

     '_m_a_s_k' An object of 'Image-class' of the same size as x in all
          three dimensions; in the 'Grayscale' mode. All zero regions
          will be excluded from object detection. 

     '_l_a_m_b_d_a' A numeric value. The regularisation parameter for the
          distance calculations, determines the trade-off between the
          Euclidian distance in the image plane and the contribution of
          the gradient of the values in 'x'. See details. 

     '_e_x_t' Extension of the neighborhood to estimate image gradient, in
          pixels in every direction from the central point, i.e. ext=1
          means a 3x3 neighborhood. 

_V_a_l_u_e:

     An image of 'Image-class', with the same object indexing as
     'seeds'. No new objects are created, only those specified by seeds
     are propagated. Use 'getObjects' to assign the feature matrix.

_D_e_t_a_i_l_s:

     The method operates by computing a discretized approximation of
     the Voronoi regions for given seed points on a manifold with a
     metric controlled by local image features.

     The metric is a Riemannian metric defined in terms of the image I
     and a regularization parameter lambda. With this metric the
     distance between pixels used to let the given seeds grow outwards
     (propagate) is

     $d^2 = (grad(I)^2 + lambda * (dx^2 + dy^2)) / (lambda + 1)$

     The gradient is calculated on a neighborhood of pixels (the width
     of which is controlled by the argument 'ext') to avoid relying on
     single (noisy) pixels. Lambda controls the weight of the Euclidian
     distance term. In case of large lambda, d turns into Euclidian
     distance in the '(x,y)'-plane. For small lambda, the distance will
     be dominated by the intensity gradient.

_A_u_t_h_o_r:

     Original CellProfiler code: Anne Carpenter <carpenter@wi.mit.edu>,
     Thouis Jones <thouis@csail.mit.edu>, In Han Kang <inthek@mit.edu>.

     Port for this package: Oleg Sklyar <osklyar@ebi.ac.uk> and
     Wolfgang Huber <huber@ebi.ac.uk>.

_L_i_c_e_n_s_e:

     The underlying 'C++' code is based on code from CellProfiler
     [1,3]. An LGPL license was granted by Thouis Jones to use this
     part of CellProfiler's code for the 'propagate' function.

_R_e_f_e_r_e_n_c_e_s:

     '[1]' _A. Carpenter, T.R. Jones, M.R. Lamprecht, C. Clarke, I.H.
     Kang, O. Friman, D. Guertin, J.H. Chang, R.A. Lindquist, J.
     Moffat, P. Golland and D.M. Sabatini_, "CellProfiler: image
     analysis software for identifying and quantifying cell
     phenotypes", Genome Biology 2006, 7:R100

     '[2]' _T. Jones, A. Carpenter and P. Golland_, "Voronoi-Based
     Segmentation of Cells on Image Manifolds", CVBIA05 (535-543), 2005

     '[3]' CellProfiler: http://www.cellprofiler.org

_S_e_e _A_l_s_o:

     ' Image-class, watershed, getObjects '

_E_x_a_m_p_l_e_s:

         if ( interactive() ) {
           ddir <- paste( system.file(package="EBImage"), "images", sep="/" )
           a <- read.image( paste(ddir, c("A04w0.jpg", "A04w1.jpg"), sep="/") )
           rgb <- channel(a[,,1],"asred") + channel(a[,,2],"asgreen")

           ## Not run: detecting nuclei by watershed
           t <- thresh( blur(a[,,2], 4, 2), 15, 15)
           t <- opening( closing(t, morphKern(9)) )
           w <- watershed( distmap(t) )

           ## Not run: generating mask for propagate
           mask <- thresh( a[,,1], 50, 50, -0.01)
           mask <- closing( mask, morphKern(13) )
           mask <- opening( mask, morphKern(11) )
           mask <- erode(mask)

           ## Not run: propagate with the mask and gradient-driven metric
           wx <- propagate( a[,,1], w, mask, 0.0001, 2)
           prev <- paintObjects(wx, paintObjects(w, rgb))
           display(prev)

           ## Not run: pure Voronoi: no mask and almost no gradient term in metric
           wx1 <- propagate( a[,,1], w, NULL, 1e8, 2)
           prev1 <- paintObjects(wx1, rgb)
           display(prev1)
         }
       

