9i$SSKrSSKrSSKJr SSKJr SSKrSSKJ r SSK J r SSK J r 0r\R"\R R#\R R%\5S55\S'\R"\R R#\R R%\5S 55\S 'S rS)S jrS r\R.SS.Sjr\ "SSSS9\R.4SS.Sjj5rS*Sjr\ "SSSS9\R.4SS.Sjj5r\R.4SS.Sjjr\R.4SjrS\R.4Sjr\R.4SSS.Sjjr\R.4Sjr \R.4Sjr!\R.4SS.S jjr"\ "SSSS9\R.4SS.S!jj5r#\R.4SS.S"jjr$\R.4SSS.S#jjr%\R.4SS.S$jjr&\R.4S%jr'S&r(SS'.S(jr)g)+N)Sequence)Integral)draw) morphology)deprecate_funczdisk_decompositions.npyzball_decompositions.npyc^[US5(agSm[U[5(a'[U4SjU55(d [ S5eg[ S5e)N__array_interface__Fc[U[5=(a> [U5S:H=(a) [USS5=(a [US[5$)Nrrr ) isinstancerlenhasattrr)ts ]/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/skimage/morphology/footprints.py_validate_sequence_element:_footprint_is_sequence.._validate_sequence_element sJ q( # +A!  +!34 +1Q4*  c34># UH nT"U5v M g7fN).0rrs r )_footprint_is_sequence..)sD)Q-a00)szAll elements of footprint sequence must be a 2-tuple where the first element of the tuple is an ndarray and the second is an integer indicating the number of iterations.z/footprint must be either an ndarray or SequenceT)rrrall ValueError) footprintrs @r_footprint_is_sequencersey/00 )X&&D)DDDE E JKKrc[U5(d [S5eUSSRnS/U-nSn[U5HnUSupgU"URUU5 URUUS- URUS- --X5'USSH9upgU"URUU5 X5==XvRUS- -- ss'M; M [ U5$)zDetermine the shape of composite footprint In the future if we only want to support odd-sized square, we may want to change this to require_odd_size z!expected a sequence of footprintsrc<U(aUS-S:Xa [S5egg)Nrrz0expected all footprint elements to have odd sizer)sizerequire_odd_sizes r _odd_size'_shape_from_sequence.._odd_size?s# qA OP P!. rr N)rrndimrangeshapetuple) footprintsr$r'r)r%dfpnrepss r_shape_from_sequencer/4s "* - -<== a=  D C$JEQ4[qM "((1+/088A;%!) a!@@#ABIB bhhqk#3 4 H!q1 1H(  <rc[U5n[R"U[S9nSU[ SU55'[ R "X 5$)aConvert a footprint sequence into an equivalent ndarray. Parameters ---------- footprints : tuple of 2-tuples A sequence of footprint tuples where the first element of each tuple is an array corresponding to a footprint and the second element is the number of times it is to be applied. Currently, all footprints should have odd size. Returns ------- footprint : ndarray An single array equivalent to applying the sequence of ``footprints``. dtyper c3*# UH oS-v M g7f)rNr)rss rr*footprint_from_sequence..as%u!Avus)r/npzerosboolr*rbinary_dilation)r+r)imags rfootprint_from_sequencer;MsD$ ! ,E 88E &D)*D%u% %&  % %d 77rr2 decompositionc0^^^ [ST55nUS:XaU(a[R"SSS9 SnUU4Sjm Uc[R"TTS9nU$US ;a [ U 4S j[ T555nU$US:Xa[T5n[US 5n[R"S [T5-TS9U4/n[ T5H,upxX:dM X- S -n T "Xy5n URU 5 M. [ U5nU$[SU35e)aGenerate a rectangular or hyper-rectangular footprint. Generates, depending on the length and dimensions requested with `shape`, a square, rectangle, cube, cuboid, or even higher-dimensional versions of these shapes. Parameters ---------- shape : tuple[int, ...] The length of the footprint in each dimension. The length of the sequence determines the number of dimensions of the footprint. dtype : data-type, optional The data type of the footprint. decomposition : {None, 'separable', 'sequence'}, optional If None, a single array is returned. For 'sequence', a tuple of smaller footprints is returned. Applying this series of smaller footprints will give an identical result to a single, larger footprint, but often with better computational performance. See Notes for more details. With 'separable', this function uses separable 1D footprints for each axis. Whether 'sequence' or 'separable' is computationally faster may be architecture-dependent. Returns ------- footprint : array or tuple[tuple[ndarray, int], ...] A footprint consisting only of ones, i.e. every pixel belongs to the neighborhood. When `decomposition` is None, this is just an array. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Examples for more detail). Examples -------- >>> import skimage as ski >>> ski.morphology.footprint_rectangle((3, 5)) array([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]], dtype=uint8) Decomposition will return multiple footprints that combine into a simple footprint of the requested shape. >>> ski.morphology.footprint_rectangle((9, 9), decomposition="sequence") ((array([[1, 1, 1], [1, 1, 1], [1, 1, 1]], dtype=uint8), 4),) `"sequence"` makes sure that the decomposition only returns 1D footprints. >>> ski.morphology.footprint_rectangle((3, 5), decomposition="separable") ((array([[1], [1], [1]], dtype=uint8), 1), (array([[1, 1, 1, 1, 1]], dtype=uint8), 1)) Generate a 5-dimensional hypercube with 3 samples in each dimension >>> ski.morphology.footprint_rectangle((3,) * 5).shape (3, 3, 3, 3, 3) c30# UH oS-S:Hv M g7f)rrNr)rwidths rr&footprint_rectangle..s;UEaUssequencezkdecomposition='sequence' is only supported for uneven footprints, falling back to decomposition='separable'r) stacklevelsequence_fallbackcr>SU-U4-S[T5U- S- --n[R"UTS9S4nU$)Nr r r1)rr6ones)dimr@shape_r-r2r)s rpartial_footprint.footprint_rectangle..partial_footprintsEuh&Uc1AA1E)FFggfE*A . rr1) separablerDc38># UHupT"X5v M g7frr)rrHr@rJs rrrAs  r'r2rNr1rF)dictdiskball_nsphere_decompositionsrr)_t_shaped_element_seriesrVr6r7slicer(r*rG)rrr'r2kwargsprecomputed_decompositions max_radius num_t_series num_diamond num_squarerBall_trr,slaxsqs r_nsphere_series_decompositionrs>{EdK 19&v&*, , QY&v&*, , ** #  "9!>+11!4J 4&!"| %  -G,N)LzHa(d@5:;U!* +U;Q HHTD[ .Aqk]T !+B4[BFAeBiL1a[BF ()A~ WWTD[ .() ? C FND~A F& qA$A1u!f773?Q&  L "16"%(!, L MMLs&E cUcK[R"SU-S-SU-S-4US9n[R"XUS-US-5upVSXEU4'U$US:Xa[XUSS9n[ U5nW$)aGenerates a flat, ellipse-shaped footprint. Every pixel along the perimeter of ellipse satisfies the equation ``(x/width+1)**2 + (y/height+1)**2 = 1``. Parameters ---------- width : int The width of the ellipse-shaped footprint. height : int The height of the ellipse-shaped footprint. Other Parameters ---------------- dtype : data-type, optional The data type of the footprint. decomposition : {None, 'crosses'}, optional If None, a single array is returned. For 'sequence', a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but with better computational performance. See Notes for more details. Returns ------- footprint : ndarray The footprint where elements of the neighborhood are 1 and 0 otherwise. The footprint will have shape ``(2 * height + 1, 2 * width + 1)``. Notes ----- When `decomposition` is not None, each element of the `footprint` tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a footprint array and the number of iterations it is to be applied. The ellipse produced by the ``decomposition='crosses'`` is often but not always identical to that with ``decomposition=None``. The method is based on an adaption of algorithm 1 given in [1]_. References ---------- .. [1] Li, D. and Ritter, G.X. Decomposition of Separable and Symmetric Convex Templates. Proc. SPIE 1350, Image Algebra and Morphological Image Processing, (1 November 1990). :DOI:`10.1117/12.23608` Examples -------- >>> from skimage.morphology import footprints >>> footprints.ellipse(5, 3) array([[0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [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], [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0]], dtype=uint8) Nrr r1rr`)r6r7rellipser) r@heightr2r=rrowscolsr-rBs rrrsvHHa&j1na%i!m'+ Orc[XU4XS9nU$)a!Generates a cube-shaped footprint. This is the 3D equivalent of a square. Every pixel along the perimeter has a chessboard distance no greater than radius (radius=floor(width/2)) pixels. Parameters ---------- width : int The width, height and depth of the cube. Other Parameters ---------------- dtype : data-type, optional The data type of the footprint. decomposition : {None, 'separable', 'sequence'}, optional If None, a single array is returned. For 'sequence', a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but often with better computational performance. See Notes for more details. Returns ------- footprint : ndarray or tuple The footprint where elements of the neighborhood are 1 and 0 otherwise. When `decomposition` is None, this is just a numpy.ndarray. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Notes for more detail) Notes ----- When `decomposition` is not None, each element of the `footprint` tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a footprint array and the number of iterations it is to be applied. For binary morphology, using ``decomposition='sequence'`` was observed to give better performance, with the magnitude of the performance increase rapidly increasing with footprint size. For grayscale morphology with square footprints, it is recommended to use ``decomposition=None`` since the internal SciPy functions that are called already have a fast implementation based on separable 1D sliding windows. The 'sequence' decomposition mode only supports odd valued `width`. If `width` is even, the sequence used will be identical to the 'separable' mode. rbrcrds rcubers!h$U#5I rcUcSU-S-n[RU*XS-2U*XS-2U*XS-24upEn[R"U5[R"U5-[R"U5-n[R"Xp:*US9nU$US:Xa0[ SUSS9n [ SU-S-U R S5n X44nU$[S U35e) aGenerates a octahedron-shaped footprint. This is the 3D equivalent of a diamond. A pixel is part of the neighborhood (i.e. labeled 1) if the city block/Manhattan distance between it and the center of the neighborhood is no greater than radius. Parameters ---------- radius : int The radius of the octahedron-shaped footprint. Other Parameters ---------------- dtype : data-type, optional The data type of the footprint. decomposition : {None, 'sequence'}, optional If None, a single array is returned. For 'sequence', a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but with better computational performance. See Notes for more details. Returns ------- footprint : ndarray or tuple The footprint where elements of the neighborhood are 1 and 0 otherwise. When `decomposition` is None, this is just a numpy.ndarray. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Notes for more detail) Notes ----- When `decomposition` is not None, each element of the `footprint` tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a footprint array and the number of iterations it is to be applied. For either binary or grayscale morphology, using ``decomposition='sequence'`` was observed to have a performance benefit, with the magnitude of the benefit increasing with increasing footprint size. Nrr ?r1rBr<rrO)r6mgridrpro octahedronrUr)r) rrr2r=rZrrr4rr-r.s rrr sV JN(( Gf2v % Gf2v % Gf2v % ' a FF1Iq !BFF1I -HHQ[6   * $ d ;F Q <[N  7 GHHrcUcjSU-S-n[RU*XS-2U*XS-2U*XS-24upVnUS-US--US--nU(dUS- n[R"XU-:*US9$US:Xa [USUS9n U $[ S U35e) aGenerates a ball-shaped footprint. This is the 3D equivalent of a disk. A pixel is within the neighborhood if the Euclidean distance between it and the origin is no greater than radius. Parameters ---------- radius : float The radius of the ball-shaped footprint. Other Parameters ---------------- dtype : data-type, optional The data type of the footprint. strict_radius : bool, optional If False, extend the radius by 0.5. This allows the circle to expand further within a cube that remains of size ``2 * radius + 1`` along each axis. This parameter is ignored if decomposition is not None. decomposition : {None, 'sequence'}, optional If None, a single array is returned. For 'sequence', a tuple of smaller footprints is returned. Applying this series of smaller footprints will given a result equivalent to a single, larger footprint, but with better computational performance. For ball footprints, the sequence decomposition is not exactly equivalent to decomposition=None. See Notes for more details. Returns ------- footprint : ndarray or tuple The footprint where elements of the neighborhood are 1 and 0 otherwise. Notes ----- The disk produced by the decomposition='sequence' mode is not identical to that with decomposition=None. Here we extend the approach taken in [1]_ for disks to the 3D case, using 3-dimensional extensions of the "square", "diamond" and "t-shaped" elements from that publication. All of these elementary elements have size ``(3,) * ndim``. We numerically computed the number of repetitions of each element that gives the closest match to the ball computed with kwargs ``strict_radius=False, decomposition=None``. Empirically, the equivalent composite footprint to the sequence decomposition approaches a rhombicuboctahedron (26-faces [2]_). References ---------- .. [1] Park, H and Chin R.T. Decomposition of structuring elements for optimal implementation of morphological operations. In Proceedings: 1997 IEEE Workshop on Nonlinear Signal and Image Processing, London, UK. https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf .. [2] https://en.wikipedia.org/wiki/Rhombicuboctahedron rr rrr1rBr rxrO)r6rrorr) rrr2rwr=rrrrr4rBs rr{r{Isn JN(( Gf2v % Gf2v % Gf2v % ' a qD1a4K!Q$  cMFxxf_,E:: * $0auM O7 GHHrc TXs=:XaS:XaO O [S5eUcSSKJn [R"USU--USU--45nSUSU4'SXQS4'SUSX-S- 4'SXPU-S- S4'SUSU4'SXQS4'SUSX-S- 4'SXPU-S- S4'U"U5R U5nU$US:XakUS::aUS::a[ XUSS 9S44$US:XaSnUS-n/nUS:aU[[X4USS 95- nUS:aU[SUSS 9U4/- n[U5nU$[S U35e) aGenerates an octagon shaped footprint. For a given size of (m) horizontal and vertical sides and a given (n) height or width of slanted sides octagon is generated. The slanted sides are 45 or 135 degrees to the horizontal axis and hence the widths and heights are equal. The overall size of the footprint along a single axis will be ``m + 2 * n``. Parameters ---------- m : int The size of the horizontal and vertical sides. n : int The height or width of the slanted sides. Other Parameters ---------------- dtype : data-type, optional The data type of the footprint. decomposition : {None, 'sequence'}, optional If None, a single array is returned. For 'sequence', a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but with better computational performance. See Notes for more details. Returns ------- footprint : ndarray or tuple The footprint where elements of the neighborhood are 1 and 0 otherwise. When `decomposition` is None, this is just a numpy.ndarray. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Notes for more detail) Notes ----- When `decomposition` is not None, each element of the `footprint` tuple is a 2-tuple of the form ``(ndarray, num_iter)`` that specifies a footprint array and the number of iterations it is to be applied. For either binary or grayscale morphology, using ``decomposition='sequence'`` was observed to have a performance benefit, with the magnitude of the benefit increasing with increasing footprint size. rzm and n cannot both be zeroNr convex_hull_imagerrBr<rO) rrr6r7astypeoctagonlistr\rqr*)mrr2r=rrrBs rrrsZ {{677'HHa!a%iQU34  !Q$ Q$"# !QUQY,"# a%!)Q, "a% R%#$ "aeai- #$ a%!)R- %i077> ( ' * $ 6a1fQdCQGI I 6A FA q5 #QF%zR H q5 '!5EqIJ JH(O  7 GHHrcSSKJn US:Xa[R"SU5nSUSS&U$SU-S-nUS-n[R"USU--USU--45nSXeXE-2XTU-24'USU--S- S-n[R"USU--USU--45nS=USU4'USU4'S=XS4'XS4'U"U5R [ 5nXh-n SXS:'U R U5$)aHGenerates a star shaped footprint. Start has 8 vertices and is an overlap of square of size `2*a + 1` with its 45 degree rotated version. The slanted sides are 45 or 135 degrees to the horizontal axis. Parameters ---------- a : int Parameter deciding the size of the star structural element. The side of the square array returned is `2*a + 1 + 2*floor(a / 2)`. Other Parameters ---------------- dtype : data-type, optional The data type of the footprint. Returns ------- footprint : ndarray The footprint where elements of the neighborhood are 1 and 0 otherwise. r r)r r Nrrr)rrr6r7rr) ar2rbfilterrrfootprint_squarerfootprint_rotatedrs rstarrs.0$Av((65)  A A QAxxQUAAI 67-.YE )* QUQ1A!a!e)QQY!789::ad/A69::d/26)*;<CCCH 4I I!m   E ""rc[U5(a[SU55$[R"U5nU[ SSS54UR -$)aMirror each dimension in the footprint. Parameters ---------- footprint : ndarray or tuple The input footprint or sequence of footprints Returns ------- inverted : ndarray or tuple The footprint, mirrored along each dimension. Examples -------- >>> footprint = np.array([[0, 0, 0], ... [0, 1, 1], ... [0, 1, 1]], np.uint8) >>> mirror_footprint(footprint) array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=uint8) c3@# UHup[U5U4v M g7fr)mirror_footprint)rr-rs rr#mirror_footprint..0sFI52&r*A.IsNr)rr*r6rr~r')rs rrrsN0i((FIFFF 9%I eD$+- > ??rpad_endc^[U5(a[U4SjU55$[R"U5n/nURH(nUR US-S:Xa T(aSOSOS5 M* [R "X5$)atPad the footprint to an odd size along each dimension. Parameters ---------- footprint : ndarray or tuple The input footprint or sequence of footprints pad_end : bool, optional If ``True``, pads at the end of each dimension (right side), otherwise pads on the front (left side). Returns ------- padded : ndarray or tuple The footprint, padded to an odd size along each dimension. Examples -------- >>> footprint = np.array([[0, 0], ... [1, 1], ... [1, 1]], np.uint8) >>> pad_footprint(footprint) array([[0, 0, 0], [1, 1, 0], [1, 1, 0]], dtype=uint8) c3@># UHup[UTS9U4v M g7f)rN) pad_footprint)rr-rrs rr pad_footprint..QsT)mB8!<)srr)rr )r r)rr)rr*r6rr)rVpad)rrpaddingszs ` rrr5sm6i((T)TTT 9%IGoo"q&A+'v6R 66) %%r)FrN)*osrQcollections.abcrnumbersrnumpyr6rrskimager _shared.utilsrr|loadpathjoindirname__file__rr/r;uint8r\rerUrkrqrr}rzrrrrrr{rrrrrrrrs< $*WWGGLL*,EF WWGGLL*,EF 0280)+bJ @ 545  5p 9 @ #%((:T:  :z((6T6r79hhFR#$288!HxxY$dYx  +-(("NJ"$CDCL @ hh22  2j XX::zxxF$dFRR4Rj((-#`@<)-!&r