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 signature 'Image, IndexedImage':
       propagate(x, seeds, mask=NULL, lambda=0.005, ext=1, ...)

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

       x: An object of 'Image' to be segmented, in the 'Grayscale'
          mode. 

   seeds: An object of 'IndexedImage' of the same size as x in all
          three dimensions. This image provides seed points for object
          detection. 

    mask: An object of 'Image' of the same size as 'x' in all three
          dimensions; in the 'Grayscale' mode. All zero regions will be
          excluded from object detection. 

  lambda: 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. 

     ext: 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. 

     ...: Reserved. 

_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.

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

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

_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.

_A_u_t_h_o_r(_s):

     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>.

_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:

     ' IndexedImage, Image, watershed, getFeatures '

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

       
       ## load images of nuclei (seed points later)
       f <- paste( system.file(package="EBImage"), "images/Gene1_G.tif", sep="/" )
       ii = readImage(f)
       ## normalize images
       ii = normalize(ii, separate=TRUE)
       ## segment
       mask = thresh(ii, 25, 25, 0.02)
       ## refine segmentation with morphology filters
       mk3 = morphKern(3)
       mk5 = morphKern(5)
       mask = dilate(erode(closing(mask, mk5), mk3), mk5)
       ## index objects with 'watershed'
       io = watershed( distmap(mask), 1.5, 1)
       if (interactive()) display(io)

       ## load images of cells (the ones to segment with propagate)
       f <- paste( system.file(package="EBImage"), "images/Gene1_R.tif", sep="/" )
       xi = readImage(f)
       ## normalize images
       xi = normalize(xi, separate=TRUE)
       ## segment
       mask = thresh(xi, 40, 40, 0.0)
       ## refine segmentation with morphology filters
       mk7 = morphKern(7)
       mask = dilate(erode(closing(mask, mk7), mk5), mk7)
       ## index objects of xi with 'propagate' using ii as seeds
       xo = propagate(xi, io, mask, 1e-5, 1.5)
       if (interactive()) display(xo)
       

