0-Ph[dZddlZddlmZddlmZddlm Z ddl m Z dd l m Z mZmZdd d Zd Zd ZejgdeZejgdeZddZejddaddddZdZdZdZdS)z9 Algorithms for computing the skeleton of a binary image N)ndimage)check_nD)crop)_compute_thin_image)_fast_skeletonize_skeletonize_loop_table_lookup_index)methodc||tdd}|dvrtd|d|jdkr||d krt |}nd|jd kr|d krtd |jd ks|jdkr|d krt |}ntd |jd|S)a Compute the skeleton of the input image via thinning. Parameters ---------- image : (M, N[, P]) ndarray of bool or int The image containing the objects to be skeletonized. Each connected component in the image is reduced to a single-pixel wide skeleton. The image is binarized prior to thinning; thus, adjacent objects of different intensities are considered as one. Zero or ``False`` values represent the background, nonzero or ``True`` values -- foreground. method : {'zhang', 'lee'}, optional Which algorithm to use. Zhang's algorithm [Zha84]_ only works for 2D images, and is the default for 2D. Lee's algorithm [Lee94]_ works for 2D or 3D images and is the default for 3D. Returns ------- skeleton : (M, N[, P]) ndarray of bool The thinned image. See Also -------- medial_axis References ---------- .. [Lee94] T.-C. Lee, R.L. Kashyap and C.-N. Chu, Building skeleton models via 3-D medial surface/axis thinning algorithms. Computer Vision, Graphics, and Image Processing, 56(6):462-478, 1994. .. [Zha84] A fast parallel algorithm for thinning digital patterns, T. Y. Zhang and C. Y. Suen, Communications of the ACM, March 1984, Volume 27, Number 3. Examples -------- >>> X, Y = np.ogrid[0:9, 0:9] >>> ellipse = (1./3 * (X - 4)**2 + (Y - 4)**2 < 3**2).astype(bool) >>> ellipse.view(np.uint8) array([[0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8) >>> skel = skeletonize(ellipse) >>> skel.view(np.uint8) array([[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) CFordercopy>Nleezhangz:skeletonize method should be either "lee" or "zhang", got .rNrz4skeletonize method "zhang" only works for 2D images.rz4skeletonize requires a 2D or 3D image as input, got zD.)astypebool ValueErrorndim_skeletonize_zhang_skeletonize_lee)imager skeletons _/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/skimage/morphology/_skeletonize.py skeletonizers| LLSuL 5 5E +++ VV V V V    zQFNf.?.?%e,, qVw..RSSS qUZ1__5#E** Uuz U U U    OcT|jdkrtdt|S)a; Return the skeleton of a 2D binary image. Thinning is used to reduce each connected component in a binary image to a single-pixel wide skeleton. Parameters ---------- image : numpy.ndarray An image containing the objects to be skeletonized. Zeros or ``False`` represent background, nonzero values or ``True`` are foreground. Returns ------- skeleton : ndarray A matrix containing the thinned image. See Also -------- medial_axis, skeletonize, thin Notes ----- The algorithm [Zha84]_ works by making successive passes of the image, removing pixels on object borders. This continues until no more pixels can be removed. The image is correlated with a mask that assigns each pixel a number in the range [0...255] corresponding to each possible pattern of its 8 neighboring pixels. A look up table is then used to assign the pixels a value of 0, 1, 2 or 3, which are selectively removed during the iterations. Note that this algorithm will give different results than a medial axis transform, which is also often referred to as "skeletonization". References ---------- .. [Zha84] A fast parallel algorithm for thinning digital patterns, T. Y. Zhang and C. Y. Suen, Communications of the ACM, March 1984, Volume 27, Number 3. Examples -------- >>> X, Y = np.ogrid[0:9, 0:9] >>> ellipse = (1./3 * (X - 4)**2 + (Y - 4)**2 < 3**2).astype(bool) >>> ellipse.view(np.uint8) array([[0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8) >>> skel = skeletonize(ellipse) >>> skel.view(np.uint8) array([[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) rz.Zhang's skeletonize method requires a 2D array)rrr )rs rrrcs-J zQIJJJ U # ##r c d fdtjfdtdD} fdtjfdtdD}||z} fd fd tj fd tdD}tj fd tdD}||z}||z}||fS) z4generate LUTs for thinning algorithm (for reference)ctjfdtddDtS)Nc g|] }|z dz S)r).0ins r z5_generate_thin_luts..nabe..s!999a!999r r )nparrayrangerr)r(s`rnabez!_generate_thin_luts..nabes>x9999U1a[[999::AA$GGGr cd}|}dD](}||s||dzs||dzdzr|dz })|dkS)Nr)rrrrr%)r(sbitsr'r.s rG1z_generate_thin_luts..G1sf tAww  AG $q1u+ q1uk1B QAv r c&g|] }|Sr%r%)r&r(r5s rr)z'_generate_thin_luts..!111rr!uu111r cd\}}|}dD]5}||s ||dz r|dz }||s||dzdzr|dz }6t||dvS)N)rr)rrrr2)rr)min)r(n1n2r4kr.s rG2z_generate_thin_luts..G2sBtAww  AAw $q1u+ aAw $A{+ a2r{{f$$r c&g|] }|Sr%r%)r&r(r@s rr)z'_generate_thin_luts..r7r c^|}|ds|ds |d o|d S)Nrrr;rr%r(r4r.s rG3z_generate_thin_luts..G3:tAww!W8Q8Q=Ed1gFFr c^|}|ds|ds |d o|d S)Nr:r1rr0r%rCs rG3pz _generate_thin_luts..G3prEr c&g|] }|Sr%r%)r&r(rDs rr)z'_generate_thin_luts..r7r c&g|] }|Sr%r%)r&r(rGs rr)z'_generate_thin_luts..s!3331A333r )r+r,r-) g1_lutg2_lutg12_lutg3_lutg3p_lutg123_lut g123p_lutr5r@rDrGr.s @@@@@r_generate_thin_lutsrQs]HHHX1111eCjj111 2 2F%%%%%X1111eCjj111 2 2FvoGGGGGGGGGGGX1111eCjj111 2 2Fh3333c 33344GH'!I Y r (rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrdtype(rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrct|dtj|ttj}tjgdgdgdgtj}|p tj}d}tjtj |}}||kro||kri|}ttfD]3}tj ||d}tj||} d|| <4tj |}|d z }||kr||ki|tS) a Perform morphological thinning of a binary image. Parameters ---------- image : binary (M, N) ndarray The image to thin. If this input isn't already a binary image, it gets converted into one: In this case, zero values are considered background (False), nonzero values are considered foreground (True). max_num_iter : int, number of iterations, optional Regardless of the value of this parameter, the thinned image is returned immediately if an iteration produces no change. If this parameter is specified it thus sets an upper bound on the number of iterations performed. Returns ------- out : ndarray of bool Thinned image. See Also -------- skeletonize, medial_axis Notes ----- This algorithm [1]_ works by making multiple passes over the image, removing pixels matching a set of criteria designed to thin connected regions while preserving eight-connected components and 2 x 2 squares [2]_. In each of the two sub-iterations the algorithm correlates the intermediate skeleton image with a neighborhood mask, then looks up each neighborhood in a lookup table indicating whether the central pixel should be deleted in that sub-iteration. References ---------- .. [1] Z. Guo and R. W. Hall, "Parallel thinning with two-subiteration algorithms," Comm. ACM, vol. 32, no. 3, pp. 359-373, 1989. :DOI:`10.1145/62065.62074` .. [2] Lam, L., Seong-Whan Lee, and Ching Y. Suen, "Thinning Methodologies-A Comprehensive Survey," IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol 14, No. 9, p. 879, 1992. :DOI:`10.1109/34.161346` Examples -------- >>> square = np.zeros((7, 7), dtype=bool) >>> square[1:-1, 2:-2] = 1 >>> square[0, 1] = 1 >>> square.view(np.uint8) array([[0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8) >>> skel = thin(square) >>> skel.view(np.uint8) array([[0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8) rrR)r2r0r)rr) @rconstant)moder)rr+ asanyarrayrrviewuint8r,infsumG123_LUT G123P_LUTndi correlatetaker) r max_num_iterskelmasknum_iter n_pts_old n_pts_newlutNDs rthinrns9J UA =d + + + 0 0 2 2 7 7 A AD 8YYY MMM:"( K K KD )26LH626$<>> square = np.zeros((7, 7), dtype=bool) >>> square[1:-1, 2:-2] = 1 >>> square.view(np.uint8) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8) >>> medial_axis(square).view(np.uint8) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8) NFirUc g|]a}tjt|tdtjt|dztdkbS)ri)rblabel _pattern_of_eight_connectr&indexs rr)zmedial_axis..siIk%00.AA!DyUW_!=!=~NNqQRr cXg|]'}tjt|dk(S)rr+r_rsrus rr)zmedial_axis..s/OOO5{51122Q6OOOr cVg|]&}dtjt|z 'S)r*rxrus rr)zmedial_axis..s/@@@ERVK&& ' ' '@@@r rrrR)rrrr+aranger,r-rbdistance_transform_edt _table_lookupmgridshapeascontiguousarrayintpr]random default_rng permutationr_lexsortint32r )rrgreturn_distancero masked_imagecenter_is_foregroundtabledistancestore_distancecornerness_table corner_scorer'jresult generator tiebreakerrs r medial_axisrhsf |||D)) ||D))..00 # dUIcNNT199$?? H"'s  hOOE#JJOOOPP Q  ),77H)!x@@U3ZZ@@@!/?@@L 8A A&EKN(:: ;DAq    FH QvYbg666A QvYbg666A  !&"( 3 3F %%c**I&&ry1A1A1C1C'D'DEEJ J L$>I J JE  bh 7 7 7E  bh 7 7 7EfaE5111 ]]4 F te u ~%% r ctj|dz|dz|dzg|dz|dz|dzg|dz|dz|d zggtS) zZ Return the pattern represented by an index value Byte decomposition of index rrr0r2rUrVrWrXr8)r+r,r)rvs rrsrs sd 8 T\54< 6 T\54< 6 T\54< 6   r c|jddks|jddkr|t}tj|jt }|ddddfxx|ddddfdzz cc<|ddddfxx|ddddfdzz cc<|ddddfxx|ddddfdzz cc<|ddddfxx|ddddfdzz cc<|ddddfxx|ddddfd zz cc<|ddddfxx|ddddfd zz cc<|ddddfxx|ddddfd zz cc<|ddddfxx|ddddfd zz cc<|ddddfxx|ddddfd zz cc<n,t tj|tj}||}|S)a\ Perform a morphological transform on an image, directed by its neighbors Parameters ---------- image : ndarray A binary image table : ndarray A 512-element table giving the transform of each pixel given the values of that pixel and its 8-connected neighbors. Returns ------- result : ndarray of same shape as `image` Transformed image Notes ----- The pixels are numbered like this:: 0 1 2 3 4 5 6 7 8 The index at a pixel is the sum of 2** for pixels that evaluate to true. rrrNrr0r2rUrVrWrXr8) r~rrr+zerosintr rr])rrindexers rr|r|sxB {1~U[^a// T""(5;,,ABB5"crc?T11AAA%QQQ-$..CRCE#2#qrr'NT11122%3B3-$..111 qqq!!!tt++ 3B35ABB<$..QRRE!""crc'NT11QQQ5QQQ<$..SbSU122qrr6]T11%b&:5"(&K&KLL 'NE Lr cn|jdks |jdkrtd|jd|tdd}|jdkr|tjdf}t j|d d }t|}t|d }|jdkr|d }|S)aCompute the skeleton of a binary image. Thinning is used to reduce each connected component in a binary image to a single-pixel wide skeleton. Parameters ---------- image : ndarray, 2D or 3D An image containing the objects to be skeletonized. Zeros or ``False`` represent background, nonzero values or ``True`` are foreground. Returns ------- skeleton : ndarray of bool The thinned image. See Also -------- skeletonize, medial_axis Notes ----- The method of [Lee94]_ uses an octree data structure to examine a 3x3x3 neighborhood of a pixel. The algorithm proceeds by iteratively sweeping over the image, and removing pixels at each iteration until the image stops changing. Each iteration consists of two steps: first, a list of candidates for removal is assembled; then pixels from this list are rechecked sequentially, to better preserve connectivity of the image. The algorithm this function implements is different from the algorithms used by either `skeletonize` or `medial_axis`, thus for 2D images the results produced by this function are generally different. References ---------- .. [Lee94] T.-C. Lee, R.L. Kashyap and C.-N. Chu, Building skeleton models via 3-D medial surface/axis thinning algorithms. Computer Vision, Graphics, and Image Processing, 56(6):462-478, 1994. rrz>skeletonize can only handle 2D or 3D images; got image.ndim = z instead.rFr.rrY) pad_widthrZ) crop_widthr) rrrrr+newaxispadrr)rimage_os rrrOsT zA~~a 6 %  6 6 6   ll4sl77G zQ"*c/*fW ;;;G"'**G7q)))G zQ!* Nr )N)NF)__doc__numpyr+scipyrrb _shared.utilsrutilr_skeletonize_lee_cyr_skeletonize_various_cyr r r rrrQr,rr`rarngenerate_binary_structurertrrsr|rr%r rrs $$$$$$444444"&NNNNNbG$G$G$Z,,,` 28 0 0 08< = = = BH 1 1 19= > > > "````J/.q!44``````F   222j@@@@@r