1-PhddlZddlZddlmZddlmZddlZddlm Z ddl m Z ddl m Z iZejejejeded<ejejejed ed <d Zd*d ZdZejdddZe dddejfdddZd+dZe dddejfdddZejfdddZejfdZdejfdZejfddddZejfdZ ejfd Z!ejfddd!Z"e dddejfddd"Z#ejfddd#Z$ejfdddd$Z%ejfddd%Z&ejfd&Z'd'Z(dd(d)Z)dS),N)Sequence)Integral)draw) morphology)deprecate_funczdisk_decompositions.npyzball_decompositions.npyct|drdSdt|tr+tfd|Dst dnt ddS)N__array_interface__Fct|toCt|dko0t|ddot|dtS)Nrrr ) isinstancerlenhasattrr)ts ]/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/skimage/morphology/footprints.py_validate_sequence_elementz:_footprint_is_sequence.._validate_sequence_element sU q( # # +A!  +!344 +1Q4**  c3.K|]}|VdSN).0rrs r z)_footprint_is_sequence..)s/DDQ--a00DDDDDDrzAll 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_sequencersy/00u   )X&&LDDDD)DDDDD E  JKKK 4rFct|std|ddj}dg|z}d}t|D]}|d\}}||j|||j||dz |j|dz zz||<|ddD]=\}}||j||||xx||j|dz zz cc<>t |S)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>|r|dzdkrtddSdS)Nrrz0expected all footprint elements to have odd sizer)sizerequire_odd_sizes r _odd_sizez'_shape_from_sequence.._odd_size?s6  QqA OPP P Q Q rr N)rrndimrangeshapetuple) footprintsr"r$r&r#dfpnrepss r_shape_from_sequencer,4s# "* - -><=== a=  D C$JEQQQ4[[22qM E "(1+/0008A;%!) a!@@a#ABB 2 2IB Ibhqk#3 4 4 4 !HHH!q1 1HHHH 2 <<rct|}tj|t}d|t d|D<t j||S)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 K|] }|dzV dS)rNr)rss rrz*footprint_from_sequence..as&%%!qAv%%%%%%r)r,npzerosboolr'rbinary_dilation)r(r&imags rfootprint_from_sequencer7MsY$ ! , ,E 8E & & &D)*D%%u%%% % %&  %dJ 7 77rr/ decompositionc~ tdD}|dkr|rtjddd}fd |tj }n|d vr)t fd t D}n|dkrt}t|d }tjd tz |fg}t D]4\}}||kr)||z dz}  || } | | 5t |}ntd||S)a_ Generate 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) c3(K|] }|dzdkVdS)rrNr)rwidths rrz&footprint_rectangle..s*;;Ea;;;;;;rsequencezkdecomposition='sequence' is only supported for uneven footprints, falling back to decomposition='separable'r) stacklevelsequence_fallbackc|d|z|fzdt|z dz zz}tj|df}|S)Nr r r.)rr2ones)dimr<shape_r*r/r&s rpartial_footprintz.footprint_rectangle..partial_footprintsKuh&Uc1AA1E)FFgfE***A . rNr.) separabler?c36K|]\}}||VdSrr)rrCr<rEs rrz&footprint_rectangle..sF  .8c5  c5 ) )      rr r r Unrecognized decomposition: ) anywarningswarnr2rBr' enumeratemin_decompose_sizerappendr) r&r/r9has_even_widthr min_widthsq_repsrCr<nextra componentrEs `` @rfootprint_rectanglerVes|;;U;;;;;N ""~"  8    ,  GE/// < < <    r$r/c>g|]}|fSr)rP)rr num_t_seriesr=s r z1_nsphere_series_decomposition..s*;;;!\* + +;;;rrHr.rA)dictdiskball_nsphere_decompositionsrr&_t_shaped_element_seriesr2r3slicer%r'rPrB)rlr$r/kwargsprecomputed_decompositions max_radius num_diamond num_squareall_tr)slaxsqrtr=s @@r_nsphere_series_decompositionrs>{{EdKKK 199&&v&&*, , QYY&&v&&*, , *** #   "9!>+1!4J  %4 % %" % %   -Gv,N)L+zHa(d%@@@;;;;;U;;;;Q HTD[ . . .Aqkk]T !++ ! !B4[[BrFAeBiiL1a[[BrFFK()))A~~ WTD[ . . .Z())) ??rch|dkrdtjgdgdgdg|}tj|d}tj|d}tj|d}||||fSg}t|D]}dD]}tjd|z|} t d g|z} t ||dz| |<d| t | <t ddg|z} t d | |<d| t | <|| t |S) aA series of T-shaped structuring elements. In the 2D case this is a T-shaped element and its rotation at multiples of 90 degrees. This series is used in efficient decompositions of disks of various radius as published in [1]_. The generalization to the n-dimensional case can be performed by having the "top" of the T to extend in (ndim - 1) dimensions and then producing a series of rotations such that the bottom end of the T points along each of ``2 * ndim`` orthogonal directions. r)r r r )rr rr.r r )rrrHN)r2rirot90r%r3r{r'rP) r$r/t0t90t180t270rridxrrs rrzrzsC qyyXyyy)))YYY7u E E Ehr1ooxAxA3d""++ B  HTD[666Dkk]T)sC!G,,2 %)) Aqkk]T)t2 %))  Q  <<rTrqr9cH|^tj| |dz}tj||\}}|s|dz }tj|dz|dzz|dzk|S|dkrt |d|}n(|dkr"t |||d }t |}|S) u Generates a flat, disk-shaped footprint. A pixel is within the neighborhood if the Euclidean distance between it and the origin is no greater than radius (This is only approximately True, when `decomposition == 'sequence'`). Parameters ---------- radius : int The radius of the disk-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', '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 a result equivalent to a single, larger footprint, but with better computational performance. For disk footprints, the 'sequence' or 'crosses' decompositions are not always exactly equivalent to ``decomposition=None``. See Notes for more details. Returns ------- footprint : ndarray The footprint where elements of the neighborhood are 1 and 0 otherwise. 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 disk produced by the ``decomposition='sequence'`` mode may not be identical to that with ``decomposition=None``. A disk footprint can be approximated by applying a series of smaller footprints of extent 3 along each axis. Specific solutions for this are given in [1]_ for the case of 2D disks with radius 2 through 10. Here, we numerically computed the number of repetitions of each element that gives the closest match to the disk computed with kwargs ``strict_radius=False, decomposition=None``. Empirically, the series decomposition at large radius approaches a hexadecagon (a 16-sided polygon [2]_). In [3]_, the authors demonstrate that a hexadecagon is the closest approximation to a disk that can be achieved for decomposition with footprints of shape (3, 3). The disk produced by the ``decomposition='crosses'`` is often but not always identical to that with ``decomposition=None``. It tends to give a closer approximation than ``decomposition='sequence'``, at a performance that is fairly comparable. The individual cross-shaped elements are not limited to extent (3, 3) in size. Unlike the 'seqeuence' decomposition, the 'crosses' decomposition can also accurately approximate the shape of disks with ``strict_radius=True``. The method is based on an adaption of algorithm 1 given in [4]_. 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/Hexadecagon .. [3] Vanrell, M and Vitrià, J. Optimal 3 × 3 decomposable disks for morphological transformations. Image and Vision Computing, Vol. 15, Issue 11, 1997. :DOI:`10.1016/S0262-8856(97)00026-7` .. [4] 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` Nr ?rr.r=rrcrossesr)r2rgrhrirrw_cross_decomposition) rlr/rqr9rmXYr=r*s rrwrws\ Ivgvz * *{1a  1  cMFxA12%@@@@ * $ $0auMMM ) # # &%}D Q Q Q'++ Orctd|zdz}td|zdz}tj||f|}|dkr d||ddf<|dkr d|dd|f<|S)zgCross-shaped structuring element of shape (r0, r1). Only the central row and column are ones. rr r.rN)intr2r3)r0r1r/s0s1cs r_crossrXs{ QVaZB QVaZB "b'''A Qww"aaa% Qww!!!R% Hrc||jddzd|jddzdf}|dt}tj|tjdgtf}d}i}d}t |jdz D][}||||dzkrD|dkr||||z ||z f}||dz }||vrd||<n||xxdz cc<|}\|jddz |z } | dkr | df}||ddz||<tfd| DS)aKDecompose a symmetric convex footprint into cross-shaped elements. This is a decomposition of the footprint into a sequence of (possibly asymmetric) cross-shaped elements. This technique was proposed in [1]_ and corresponds roughly to algorithm 1 of that publication (some details had to be modified to get reliable operation). .. [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` rrNr r.cBg|]\\}}}t|||fSr)r)rrrnr/s rruz(_cross_decomposition..s2LLL"b16"b%((!,LLLr) r&sumrr2 concatenateasarrayr%r!getr'items) rr/quadrantcol_sumsi_prevrsum0ikeyrs ` rrrgs+q022IOA4F!4K4M4MMNH||AS|))H~xQCs)C)C)CDEEH F C D 8=1$ % %   A;!a% ( (AvvF#hqk11v:>C CFND#~~CCA FqA$A1uu!f773??Q&C LLLL LLL M MMrc|Mtjd|zdzd|zdzf|}tj|||dz|dz\}}d|||f<|S|dkr"t|||d}t |}|S)aqGenerates 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 r.rrZ)r2r3rellipser) r<heightr/r9rrowscolsr*r=s rrrsvHa&j1na%i!m > >'++ Orc0t|||f||}|S)aGenerates 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. r\r]r^s rcubers/h$eU#5 I rc|d|zdz}tj| ||dz| ||dz| ||dzf\}}}tj|tj|ztj|z}tj||k|}nQ|dkr9t d|d} t d|zdz| jd} | | ff}ntd ||S) aoGenerates 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 ?r.r=r8rrI)r2mgridrjri octahedronrOr&r) rlr/r9rZrrr1rr*r+s rrr sV JN( Gfq2v % Gfq2v % Gfq2v % ' 1a F1IIq !BF1II -HQ&[666 * $ $ d ; ; ;F Q <<%[N G GGHHH rc6|kd|zdz}tj| ||dz| ||dz| ||dzf\}}}|dz|dzz|dzz}|s|dz }tj|||zk|S|dkrt|d| } nt d || S) ab Generates 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 Nrr rrr.r=r rrrI)r2rrirr) rlr/rqr9rrrrr1r=s rrxrxIsn JN( Gfq2v % Gfq2v % Gfq2v % ' 1a qD1a4K!Q$   cMFxVf_,E:::: * $ $0auMMMG GGHHH Orc||cxkrdkrnntd|ddlm}tj|d|zz|d|zzf}d|d|f<d||df<d|d||zdz f<d|||zdz df<d|d|f<d||df<d|d||zdz f<d|||zdz df<|||}n|dkr|dkr|dkrt |||d dffS|dkrd}|dz}g}|dkr$|tt||f|d z }|dkr|td|d |fgz }t|}ntd ||S) 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_imagerr=r8rI) rrr2r3astypeoctagonlistrVrkr')mrr/r9rrr=s rrrsZ A{{{{{{{{{6777''''''Ha!a%iQU344  !Q$ !Q$"# !QUQY,"# !a%!)Q, "a% !R%#$ "a!eai- #$ !a%!)R- %%i0077>> * $ $ 66a1ffQdCCCQGI I 66A FA q55 #QF%zRRR H q55 '!5EEEqIJ JH(OO G GGHHH rcddlm}|dkrtjd|}d|dd<|Sd|zdz}|dz}tj|d|zz|d|zzf}d||||z|||zf<|d|zzdz dz}tj|d|zz|d|zzf}dx|d|f<|d|f<dx||df<||df<||t }||z} d| | dk<| |S)aGenerates 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)rrr2r3rr) ar/rbfilterrrfootprint_squarerfootprint_rotatedrs rstarrsa0$#####Avv(65))  A A QAxQUAAI 677-.QQYAE )* QUQ1A!a!e)QQY!7889::ad/A69::ad/26))*;<<CCCHH #44I Ii!m   E " ""rct|rtd|DStj|}|t dddf|jzS)a'Mirror 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>K|]\}}t||fVdSr)mirror_footprint)rr*rs rrz#mirror_footprint..0s4FF52q&r**A.FFFFFFrNr)rr'r2rr{r$)rs rrrsb0i((GFFIFFFFFF 9%%I eD$++- > ??rpad_endc t|rtfd|DStj|}g}|jD]&}||dzdkrrdndnd'tj||S)aPad 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) c3DK|]\}}t||fVdS)rN) pad_footprint)rr*rrs rrz pad_footprint..Qs9TTQmB888!<TTTTTTrrr)rr )r r)rr)rr'r2rr&rPpad)rrpaddingszs ` rrr5s6i((UTTTT)TTTTTT 9%%IGoSS"q&A++'5vv6RRRR 6)W % %%r)FrH)*osrKcollections.abcrnumbersrnumpyr2rrskimager _shared.utilsrryloadpathjoindirname__file__rr,r7uint8rVr_rOrerkrrzrwrrrrrrxrrrrrrrrs9 $$$$$$******$RWGLL**,EFF%RWGLL**,EFF 028880)+bbbbbJ @ 545555  5p 9 9 9 9 @ #%(:T::::  :z(6T66666r79hFFFFR#$28!!!!HxY$dYYYYYx     +-("N"N"N"NJ"$CDCCCCCL @ h22222  2j X::::::zxF$dFFFFFRR4RRRRRj(-#-#-#-#`@@@<)-!&!&!&!&!&!&!&r