ó  ‰\c@sôdZddlZddlmZmZddlmZyAddl m Z e j j Z d„Zee j _ e j ƒZ Wn eZ nXyddlmZeZWnek r¼eZnXdd lmZdd lmZdd lmZddlZdd lmZddlZeej ƒed ƒkrHej!eddƒZnd„Z"dded„Z#d„Z$d„Z%ed„Z&d„Z'd„Z(eded„Z)d„Z*dddeeeed„Z+ed„Z,ed „Z-ed!„Z.dS("s Random walker segmentation algorithm from *Random walks for image segmentation*, Leo Grady, IEEE Trans Pattern Anal Mach Intell. 2006 Nov;28(11):1768-83. Installing pyamg and using the 'cg_mg' mode of random_walker improves significantly the performance. iÿÿÿÿN(tsparsetndimagei(twarn(tumfpackcCs&yt|ƒWntk r!nXdS(N(told_deltAttributeError(tself((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pytnew_dels (truge_stuben_solver(t img_as_float(t rank_order(tcg(t LooseVersions1.1tatolicCstj|||ƒj|||fƒ}tj|dd…dd…dd…fjƒ|dd…dd…dd…fjƒfƒ}tj|dd…dd…fjƒ|dd…dd…fjƒfƒ}tj|d jƒ|djƒfƒ}tj|||fƒ}|S(s!Returns a list of edges for a 3D image. Parameters ---------- n_x: integer The size of the grid in the x direction. n_y: integer The size of the grid in the y direction n_z: integer The size of the grid in the z direction Returns ------- edges : (2, N) ndarray with the total number of edges:: N = n_x * n_y * (nz - 1) + n_x * (n_y - 1) * nz + (n_x - 1) * n_y * nz Graph edges with each column describing a node-id pair. Niÿÿÿÿi(tnptarangetreshapetvstacktravelthstack(tn_xtn_ytn_ztverticest edges_deept edges_rightt edges_downtedges((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_make_graph_edges_3d8s).1%()i‚gíµ ÷Æ°>cCs§d}x?td|jdƒD]'}|t|d|f|ƒd7}qW|d|jƒ:}|r|tj|jdƒ:}n||9}tj| ƒ}||7}|S(Niiÿÿÿÿ.ii (trangetshapet_compute_gradients_3dtstdRtsqrttexp(tdatatspacingtbetatepst multichannelt gradientstchanneltweights((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_compute_weights_3dYs  cCsétj|dd…dd…dd…f|dd…dd…dd…fƒjƒ|d}tj|dd…dd…f|dd…dd…fƒjƒ|d}tj|d |dƒjƒ|d}tj|||fS(Niÿÿÿÿiii(RtabsRtr_(R#R$tgr_deeptgr_righttgr_down((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyRms_M)c Cs|jƒd}tj|ƒ}tj|d|dfƒ}tj|d|dfƒ}tj| | fƒ}tj|||ffd||fƒ}tj|jddƒƒ }tjtj||fƒtj||fƒtj||fƒffd||fƒ}|jƒS(s Sparse implementation iiRtaxis( tmaxRRRRt coo_matrixRtsumttocsr( RR*tpixel_nbtdiagt i_indicest j_indicesR#tlaptconnect((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_make_laplacian_sparsets$cCsM|j|jƒ}|r*tj|ƒ}ntj|ƒ}|||dk<|S(Ni(tastypetdtypeRtcopyR(tXtlabelsR?((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_clean_labels_ar‡s c Csì||dk}tj|jƒ}||dk}||dk}||dd…|f}||dd…|f}|jƒ}g}xWtd|dƒD]B}|||k} tj| ƒ} | jƒ} |j|| ƒqœW||fS(s„ Build the matrix A and rhs B of the linear system to solve. A and B are two block of the laplacian of the image graph. iNi( RRtsizeR2RRt csr_matrixt transposetappend( t lap_sparseRAtindicestunlabeled_indicest seeds_indicestBtnlabelstrhstlabtmasktfs((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_buildABs  cCsStj|dd…dd…dd…fjƒ|dd…dd…fjƒ|d jƒfƒ}tj|dd…dd…dd…fjƒ|dd…dd…fjƒ|djƒfƒ}tj||ƒ}|dd…|f||}}|jƒ}tjtj|jƒƒtj|dƒƒ}||jtj ƒ}||fS(sq Remove edges of the graph connected to masked nodes, as well as corresponding weights of the edges. Niÿÿÿÿi( RRRt logical_andR2t searchsortedtuniqueRR=tint64(RR*ROtmask0tmask1tind_masktmax_node_indextorder((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_mask_edges_weights¦sMM! i2c sžt‡fd†tdƒDƒƒ\}}}t|||ƒ}tˆ|d|ddd|ƒ} |dk r…t|| |ƒ\}} nt|| ƒ} ~~ | S(Nc3s|]}ˆj|VqdS(N(R(t.0ti(R#(sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pys »siR%R&g»½×Ùß|Û=R'(ttupleRRR+tNoneR[R<( R#R$ROR%R'tl_xtl_ytl_zRR*R:((R#sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_build_laplacian¹s+  cCsotj|dkd|dkƒ}tj|dktj|ƒƒ}tj|ƒ}||}d||<||fS(sÆ Prune isolated seed pixels to prevent labeling errors, and return coordinates and label values of isolated seeds, so that it is possible to put labels back in random walker output. iROiÿÿÿÿ(tnditbinary_propagationRRRt logical_nottnonzero(RAtfilltisolatedtindstvalues((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt_check_isolated_seedsÆs !!  tbfgü©ñÒMbP?c  Cs§|dkr9trd}q`tdk r0d}q`d}n'|dkr`tdjd|ƒƒ‚ntdkr…|dkr…tdƒn|dkjƒr.tdƒ|r$tj|ƒ} | | dk} tj |j t | ƒfd tj ƒ} x9t | ƒD]"\} } || k| d | f> 'cg' with UMFPACK > 'bf'). - 'bf' (brute force): an LU factorization of the Laplacian is computed. This is fast for small images (<1024x1024), but very slow and memory-intensive for large images (e.g., 3-D volumes). - 'cg' (conjugate gradient): the linear system is solved iteratively using the Conjugate Gradient method from scipy.sparse.linalg. This is less memory-consuming than the brute force method for large images, but it is quite slow. - 'cg_mg' (conjugate gradient with multigrid preconditioner): a preconditioner is computed using a multigrid solver, then the solution is computed with the Conjugate Gradient method. This mode requires that the pyamg module (http://pyamg.org/) is installed. For images of size > 512x512, this is the recommended (fastest) mode. tol : float tolerance to achieve when solving the linear system, in cg' and 'cg_mg' modes. copy : bool If copy is False, the `labels` array will be overwritten with the result of the segmentation. Use copy=False if you want to save on memory. multichannel : bool, default False If True, input data is parsed as multichannel data (see 'data' above for proper input format in this case) return_full_prob : bool, default False If True, the probability that a pixel belongs to each of the labels will be returned, instead of only the most likely label. spacing : iterable of floats Spacing between voxels in each spatial dimension. If `None`, then the spacing between pixels/voxels in each dimension is assumed 1. Returns ------- output : ndarray * If `return_full_prob` is False, array of ints of same shape as `data`, in which each pixel has been labeled according to the marker that reached the pixel first by anisotropic diffusion. * If `return_full_prob` is True, array of floats of shape `(nlabels, data.shape)`. `output[label_nb, i, j]` is the probability that label `label_nb` reaches the pixel `(i, j)` first. See also -------- skimage.morphology.watershed: watershed segmentation A segmentation algorithm based on mathematical morphology and "flooding" of regions from markers. Notes ----- Multichannel inputs are scaled with all channel data combined. Ensure all channels are separately normalized prior to running this algorithm. The `spacing` argument is specifically for anisotropic datasets, where data points are spaced differently in one or more spatial dimensions. Anisotropic data is commonly encountered in medical imaging. The algorithm was first proposed in *Random walks for image segmentation*, Leo Grady, IEEE Trans Pattern Anal Mach Intell. 2006 Nov;28(11):1768-83. The algorithm solves the diffusion equation at infinite times for sources placed on markers of each phase in turn. A pixel is labeled with the phase that has the greatest probability to diffuse first to the pixel. The diffusion equation is solved by minimizing x.T L x for each phase, where L is the Laplacian of the weighted graph of the image, and x is the probability that a marker of the given phase arrives first at a pixel by diffusion (x=1 on markers of the phase, x=0 on the other markers, and the other coefficients are looked for). Each pixel is attributed the label for which it has a maximal value of x. The Laplacian L of the image is defined as: - L_ii = d_i, the number of neighbors of pixel i (the degree of i) - L_ij = -w_ij if i and j are adjacent pixels The weight w_ij is a decreasing function of the norm of the local gradient. This ensures that diffusion is easier between pixels of similar values. When the Laplacian is decomposed into blocks of marked and unmarked pixels:: L = M B.T B A with first indices corresponding to marked pixels, and then to unmarked pixels, minimizing x.T L x for one phase amount to solving:: A x = - B x_m where x_m = 1 on markers of the given phase, and 0 on other markers. This linear system is solved in the algorithm using a direct method for small images, and an iterative method for larger images. Examples -------- >>> np.random.seed(0) >>> a = np.zeros((10, 10)) + 0.2 * np.random.rand(10, 10) >>> a[5:8, 5:8] += 1 >>> b = np.zeros_like(a) >>> b[3, 3] = 1 # Marker for first phase >>> b[6, 6] = 2 # Marker for second phase >>> random_walker(a, b) array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 2, 2, 2, 1, 1], [1, 1, 1, 1, 1, 2, 2, 2, 1, 1], [1, 1, 1, 1, 1, 2, 2, 2, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], dtype=int32) tcg_mgR RmsB{mode} is not a valid mode. Valid modes are 'cg_mg', 'cg' and 'bf'tmodes)"cg" mode will be used, but it may be slower than "bf" because SciPy was built without UMFPACK. Consider rebuilding SciPy with UMFPACK; this will greatly accelerate the conjugate gradient ("cg") solver. You may also install pyamg and run the random_walker function in "cg_mg" mode (see docstring).is…Random walker only segments unlabeled areas, where labels == 0. No zero valued areas in labels were found. Returning provided labels.R>.iis=For non-multichannel input, data must be of dimension 2 or 3.s9For multichannel input, data must have 3 or 4 dimensions.Ngð?s`Input argument `spacing` incorrect, should be an iterable with one number per spatial dimension.iROiÿÿÿÿR%R'ttoltreturn_full_probspyamg (http://pyamg.org/)) is needed to use this mode, but is not installed. The 'cg' mode will be used instead.R?(RnR Rm(.i(gð?(gð?gð?gð?(.R_t amg_loadedtUmfpackContextt ValueErrortformatRtallRRTtemptyRtlentboolt enumeratetndimt atleast_3dR tnewaxistasarrayR-R?RltanytdiffR R=R>tint32RdReRRRfRcRQt _solve_cgt _solve_cg_mgt _solve_bftfloattarrayRBtTrueRRtintR2tsqueeze(R#RAR%RoRpR?R'RqR$t unique_labelst out_labelstnR]tdimst label_valuestinds_isolated_seedstisolated_valuesROtfilledRGRKR@tXlinetmask_i((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt random_walker×s¬“           %  .   '!%           1& cCsš|jƒ}tjj|jtjƒƒ}tjgtt |ƒƒD],}|tj|| j ƒƒj ƒƒ^qCƒ}|s–tj |ddƒ}n|S(s¾ solves lap_sparse X_i = B_i for each phase i. An LU decomposition of lap_sparse is computed first. For each pixel, the label i corresponding to the maximal X_i is returned. R1i( ttocscRtlinalgt factorizedR=RtdoubleR†RRxttoarrayRtargmax(RGRKRqtsolverR]R@((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyR„øs  EcCs‘|jƒ}g}xKtt|ƒƒD]7}t|||jƒ d|ƒd}|j|ƒq%W|stj|ƒ}tj|ddƒ}n|S(s® solves lap_sparse X_i = B_i for each phase i, using the conjugate gradient method. For each pixel, the label i corresponding to the maximal X_i is returned. RpiR1( R•RRxR R™RFRR†Rš(RGRKRpRqR@R]tx0((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyR‚s $c Cs¯g}t|ƒ}|jddƒ}xWtt|ƒƒD]C}t|||jƒ d|d|ddƒd}|j|ƒq7W|s«tj|ƒ}tj |ddƒ}n|S( së solves lap_sparse X_i = B_i for each phase i, using the conjugate gradient method with a multigrid preconditioner (ruge-stuben from pyamg). For each pixel, the label i corresponding to the maximal X_i is returned. tcycletVRptMtmaxiteriiR1( RtaspreconditionerRRxR R™RFRR†Rš( RGRKRpRqR@tmlRŸR]Rœ((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyRƒs 0(/t__doc__tnumpyRtscipyRRRdt _shared.utilsRtscipy.sparse.linalg.dsolveRRst__del__RRR_tpyamgRR‡Rrt ImportErrortFalsetutilR tfiltersR tscipy.sparse.linalgR tdistutils.versionR tVersiont functoolst __version__tpartialRR+RR<RBRQR[RcRlR”R„R‚Rƒ(((sNlib/python2.7/site-packages/skimage/segmentation/random_walker_segmentation.pyt sR           !       ÿ!