L idddlZddlZddlZddlmZddlmZddlmZgdZdZ ddZ d Z d Z d dd d Z d dd d Z d!dd dZ d!dd dZ d"dd dZ d#dd dZd$dd dZ d%dd dZ d%dd dZ d%dd dZ d%dd dZ d%dd dZ d%dd dZ d%dd dZ d%dd dZ d&dZ d'dZ d(dZdZy))N) _ni_support) _nd_image)_filters)iterate_structuregenerate_binary_structurebinary_erosionbinary_dilationbinary_openingbinary_closingbinary_hit_or_missbinary_propagationbinary_fill_holes grey_erosion grey_dilation grey_opening grey_closingmorphological_gradientmorphological_laplace white_tophat black_tophatdistance_transform_bfdistance_transform_cdtdistance_transform_edtc tj|}tt|j|Dcgc] \}}||dzzc}}}t ||Scc}}w)N)npasarraytuplezipshapebool) structureoriginssoocoors _/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/scipy/ndimage/_morphology.py_center_is_truer)0sY 9%I S17.9:62r"rQw,: ;D  $  :sA cR tj|dkrjS|dz }jDcgc] }|||dz zz}}t t |Dcgc]}|j|dzzc} t fdt t |D}tj|t}dk7||<t||}||Stj|j}|Dcgc]}||z }}||fScc}wcc}wcc}w)a Iterate a structure by dilating it with itself. Parameters ---------- structure : array_like Structuring element (an array of bools, for example), to be dilated with itself. iterations : int number of dilations performed on the structure with itself origin : optional If origin is None, only the iterated structure is returned. If not, a tuple of the iterated structure and the modified origin is returned. Returns ------- iterate_structure : ndarray of bools A new structuring element obtained by dilating `structure` (`iterations` - 1) times with itself. See Also -------- generate_binary_structure Examples -------- >>> from scipy import ndimage >>> struct = ndimage.generate_binary_structure(2, 1) >>> struct.astype(int) array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) >>> ndimage.iterate_structure(struct, 2).astype(int) array([[0, 0, 1, 0, 0], [0, 1, 1, 1, 0], [1, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0]]) >>> ndimage.iterate_structure(struct, 3).astype(int) array([[0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0]]) rrc3dK|]'}t||j|zd)ywN)slicer!).0iiposr#s r( z$iterate_structure..os8-c"gs2w)<>> from scipy import ndimage >>> import numpy as np >>> struct = ndimage.generate_binary_structure(2, 1) >>> struct array([[False, True, False], [ True, True, True], [False, True, False]], dtype=bool) >>> a = np.zeros((5,5)) >>> a[2, 2] = 1 >>> a array([[ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.]]) >>> b = ndimage.binary_dilation(a, structure=struct).astype(a.dtype) >>> b array([[ 0., 0., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 1., 1., 1., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 0.]]) >>> ndimage.binary_dilation(b, structure=struct).astype(a.dtype) array([[ 0., 0., 1., 0., 0.], [ 0., 1., 1., 1., 0.], [ 1., 1., 1., 1., 1.], [ 0., 1., 1., 1., 0.], [ 0., 0., 1., 0., 0.]]) >>> struct = ndimage.generate_binary_structure(2, 2) >>> struct array([[ True, True, True], [ True, True, True], [ True, True, True]], dtype=bool) >>> struct = ndimage.generate_binary_structure(3, 1) >>> struct # no diagonal elements array([[[False, False, False], [False, True, False], [False, False, False]], [[False, True, False], [ True, True, True], [False, True, False]], [[False, False, False], [False, True, False], [False, False, False]]], dtype=bool) rTdtyper)rarrayr"fabsindicesaddreduce)rank connectivityoutputs r(rr|skfa  axxxD)) WWRZZd +a/ 0F VV]]61 %F \ !!c  tj|}tj|}|j j s+|j jstj|}|j} tj|r tdtj| |j} t| } | t| d}ntj|t}| | kDrt!j"| | |d}|j|jk7r t%d|j j&s|j)}|j*dkr t%d|9tj|}|j,|j,k7r t%d tj.|| }t!j0| | |}t3||} t5|tj6r tj|rtd t}tj8||}tj:||}|r"|}tj8|j<|}|dk(rt?j@|||||||| d n| r|st?j@|||||||| d \}}|tCtEddd g|jz}tGt|D]+}|| ||<|j,|dzr||xxdzcc<-|%tj|tjH}|j j&s|j)}t?jJ||||dz |||ntjL|t}|}|dk\r |dzs||}}t?j@|||||||| d }d}||ks|dkr6|r4||}}t?j@|||||||| d }|dz }||kr,|dkr|r4|r|d <|}|S#t$r} td| d} ~ wwxYw)Nz)iterations parameter should be an integerzComplex type not supportedrr>r#)footprint_namez1structure and input must have same dimensionalityzstructure must not be emptyz$mask and input must have equal sizesz!Complex output type not supportedr.)'operatorindex TypeErrorrrflags c_contiguous f_contiguousascontiguousarrayr8 iscomplexobjr _check_axesr5rr"r_expand_footprint RuntimeError contiguousr3sizer!r7_expand_originr) isinstancendarray _get_outputmay_share_memoryr?rr rr-r4int8binary_erosion2 empty_like)inputr#r2maskrH border_valuer$invert brute_forceaxeser8num_axescit temp_neededtempchangedcoordinate_listr/tmp_intmp_outs r(_binary_erosionrqsL^^J/  JJu E ;; # #EKK,D,D$$U+ ::D u455  " "4 4D4yH-h: JJy5  h..tT9>IK ~~#NOO ?? % %NN$ ~~899 zz$ :: $EF F  , ,VX >F  $ $T4 8F )V ,C&"**% ??6 "?@ @  $ $VU 3F%%eV4K((u=Q   4!-vvsA G [#,#;#; 9dF &&#q$2 eU4r%:$;$-NN%345 F $ B *F2J??2&*r a    ::d"''2D))!(I!!&)T:>"(&/ CuD1 ?:>%vGF** 9dG &&#q2:o*q.W%vGF.. 4ffc16G !GB :o*q.W S  Me LCD!KLsP&& Q/ P;;Qrgc *t|||||||d|| S)a Multidimensional binary erosion with a given structuring element. Binary erosion is a mathematical morphology operation used for image processing. Parameters ---------- input : array_like Binary image to be eroded. Non-zero (True) elements form the subset to be eroded. structure : array_like, optional Structuring element used for the erosion. Non-zero elements are considered True. If no structuring element is provided, an element is generated with a square connectivity equal to one. iterations : int, optional The erosion is repeated `iterations` times (one, by default). If iterations is less than 1, the erosion is repeated until the result does not change anymore. mask : array_like, optional If a mask is given, only those elements with a True value at the corresponding mask element are modified at each iteration. output : ndarray, optional Array of the same shape as input, into which the output is placed. By default, a new array is created. border_value : int (cast to 0 or 1), optional Value at the border in the output array. origin : int or tuple of ints, optional Placement of the filter, by default 0. brute_force : boolean, optional Memory condition: if False, only the pixels whose value was changed in the last iteration are tracked as candidates to be updated (eroded) in the current iteration; if True all pixels are considered as candidates for erosion, regardless of what happened in the previous iteration. False by default. axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- binary_erosion : ndarray of bools Erosion of the input by the structuring element. See Also -------- grey_erosion, binary_dilation, binary_closing, binary_opening, generate_binary_structure Notes ----- Erosion [1]_ is a mathematical morphology operation [2]_ that uses a structuring element for shrinking the shapes in an image. The binary erosion of an image by a structuring element is the locus of the points where a superimposition of the structuring element centered on the point is entirely contained in the set of non-zero elements of the image. References ---------- .. [1] https://en.wikipedia.org/wiki/Erosion_%28morphology%29 .. [2] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((7,7), dtype=int) >>> a[1:6, 2:5] = 1 >>> a 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]]) >>> ndimage.binary_erosion(a).astype(a.dtype) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 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]]) >>> #Erosion removes objects smaller than the structure >>> ndimage.binary_erosion(a, structure=np.ones((5,5))).astype(a.dtype) 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, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) r)rq) rbr#r2rcrHrdr$rfrgs r(r r 1s)D 5)Z!<K OOrIc tj|}tj||j}t |} | t | d}tj|| }tj|}|ttdddg|jz}tt |D]+} ||  || <|j| dzr|| xxdzcc<-t|||||||d|| S)a Multidimensional binary dilation with the given structuring element. Parameters ---------- input : array_like Binary array_like to be dilated. Non-zero (True) elements form the subset to be dilated. structure : array_like, optional Structuring element used for the dilation. Non-zero elements are considered True. If no structuring element is provided an element is generated with a square connectivity equal to one. iterations : int, optional The dilation is repeated `iterations` times (one, by default). If iterations is less than 1, the dilation is repeated until the result does not change anymore. Only an integer of iterations is accepted. mask : array_like, optional If a mask is given, only those elements with a True value at the corresponding mask element are modified at each iteration. output : ndarray, optional Array of the same shape as input, into which the output is placed. By default, a new array is created. border_value : int (cast to 0 or 1), optional Value at the border in the output array. origin : int or tuple of ints, optional Placement of the filter, by default 0. brute_force : boolean, optional Memory condition: if False, only the pixels whose value was changed in the last iteration are tracked as candidates to be updated (dilated) in the current iteration; if True all pixels are considered as candidates for dilation, regardless of what happened in the previous iteration. False by default. axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- binary_dilation : ndarray of bools Dilation of the input by the structuring element. See Also -------- grey_dilation, binary_erosion, binary_closing, binary_opening, generate_binary_structure Notes ----- Dilation [1]_ is a mathematical morphology operation [2]_ that uses a structuring element for expanding the shapes in an image. The binary dilation of an image by a structuring element is the locus of the points covered by the structuring element, when its center lies within the non-zero points of the image. References ---------- .. [1] https://en.wikipedia.org/wiki/Dilation_%28morphology%29 .. [2] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((5, 5)) >>> a[2, 2] = 1 >>> a array([[ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.]]) >>> ndimage.binary_dilation(a) array([[False, False, False, False, False], [False, False, True, False, False], [False, True, True, True, False], [False, False, True, False, False], [False, False, False, False, False]], dtype=bool) >>> ndimage.binary_dilation(a).astype(a.dtype) array([[ 0., 0., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 1., 1., 1., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 0.]]) >>> # 3x3 structuring element with connectivity 1, used by default >>> struct1 = ndimage.generate_binary_structure(2, 1) >>> struct1 array([[False, True, False], [ True, True, True], [False, True, False]], dtype=bool) >>> # 3x3 structuring element with connectivity 2 >>> struct2 = ndimage.generate_binary_structure(2, 2) >>> struct2 array([[ True, True, True], [ True, True, True], [ True, True, True]], dtype=bool) >>> ndimage.binary_dilation(a, structure=struct1).astype(a.dtype) array([[ 0., 0., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 1., 1., 1., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 0.]]) >>> ndimage.binary_dilation(a, structure=struct2).astype(a.dtype) array([[ 0., 0., 0., 0., 0.], [ 0., 1., 1., 1., 0.], [ 0., 1., 1., 1., 0.], [ 0., 1., 1., 1., 0.], [ 0., 0., 0., 0., 0.]]) >>> ndimage.binary_dilation(a, structure=struct1,\ ... iterations=2).astype(a.dtype) array([[ 0., 0., 1., 0., 0.], [ 0., 1., 1., 1., 0.], [ 1., 1., 1., 1., 1.], [ 0., 1., 1., 1., 0.], [ 0., 0., 1., 0., 0.]]) NrrL) rrrrUr8r5rr7rr-r4r!rq) rbr#r2rcrHrdr$rfrgrir/s r(r r sr JJu E  " "4 4D4yH-h:  , ,VX >F 9%I%tT2!6 7 )!/01ICK Rj[r r"Q& 2J!OJ 5)Z!<K OOrIc tj|}tj||j}t |} | t | d}t||||d|||| } t| |||||||| S)a Multidimensional binary opening with the given structuring element. The *opening* of an input image by a structuring element is the *dilation* of the *erosion* of the image by the structuring element. Parameters ---------- input : array_like Binary array_like to be opened. Non-zero (True) elements form the subset to be opened. structure : array_like, optional Structuring element used for the opening. Non-zero elements are considered True. If no structuring element is provided an element is generated with a square connectivity equal to one (i.e., only nearest neighbors are connected to the center, diagonally-connected elements are not considered neighbors). iterations : int, optional The erosion step of the opening, then the dilation step are each repeated `iterations` times (one, by default). If `iterations` is less than 1, each operation is repeated until the result does not change anymore. Only an integer of iterations is accepted. output : ndarray, optional Array of the same shape as input, into which the output is placed. By default, a new array is created. origin : int or tuple of ints, optional Placement of the filter, by default 0. mask : array_like, optional If a mask is given, only those elements with a True value at the corresponding mask element are modified at each iteration. .. versionadded:: 1.1.0 border_value : int (cast to 0 or 1), optional Value at the border in the output array. .. versionadded:: 1.1.0 brute_force : boolean, optional Memory condition: if False, only the pixels whose value was changed in the last iteration are tracked as candidates to be updated in the current iteration; if true all pixels are considered as candidates for update, regardless of what happened in the previous iteration. False by default. .. versionadded:: 1.1.0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- binary_opening : ndarray of bools Opening of the input by the structuring element. See Also -------- grey_opening, binary_closing, binary_erosion, binary_dilation, generate_binary_structure Notes ----- *Opening* [1]_ is a mathematical morphology operation [2]_ that consists in the succession of an erosion and a dilation of the input with the same structuring element. Opening, therefore, removes objects smaller than the structuring element. Together with *closing* (`binary_closing`), opening can be used for noise removal. References ---------- .. [1] https://en.wikipedia.org/wiki/Opening_%28morphology%29 .. [2] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((5,5), dtype=int) >>> a[1:4, 1:4] = 1; a[4, 4] = 1 >>> a array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 1]]) >>> # Opening removes small objects >>> ndimage.binary_opening(a, structure=np.ones((3,3))).astype(int) array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) >>> # Opening can also smooth corners >>> ndimage.binary_opening(a).astype(int) array([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]) >>> # Opening is the dilation of the erosion of the input >>> ndimage.binary_erosion(a).astype(int) array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) >>> ndimage.binary_dilation(ndimage.binary_erosion(a)).astype(int) array([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]) Nrrr) rrrrUr8r5rr r rbr#r2rHr$rcrdrfrgritmps r(r r "sl JJu E  " "4 4D4yH-h:  :tT%v{ GC 3 :tV'4 IIrIc tj|}tj||j}t |} | t | d}t||||d|||| } t| |||||||| S)a Multidimensional binary closing with the given structuring element. The *closing* of an input image by a structuring element is the *erosion* of the *dilation* of the image by the structuring element. Parameters ---------- input : array_like Binary array_like to be closed. Non-zero (True) elements form the subset to be closed. structure : array_like, optional Structuring element used for the closing. Non-zero elements are considered True. If no structuring element is provided an element is generated with a square connectivity equal to one (i.e., only nearest neighbors are connected to the center, diagonally-connected elements are not considered neighbors). iterations : int, optional The dilation step of the closing, then the erosion step are each repeated `iterations` times (one, by default). If iterations is less than 1, each operations is repeated until the result does not change anymore. Only an integer of iterations is accepted. output : ndarray, optional Array of the same shape as input, into which the output is placed. By default, a new array is created. origin : int or tuple of ints, optional Placement of the filter, by default 0. mask : array_like, optional If a mask is given, only those elements with a True value at the corresponding mask element are modified at each iteration. .. versionadded:: 1.1.0 border_value : int (cast to 0 or 1), optional Value at the border in the output array. .. versionadded:: 1.1.0 brute_force : boolean, optional Memory condition: if False, only the pixels whose value was changed in the last iteration are tracked as candidates to be updated in the current iteration; if true al pixels are considered as candidates for update, regardless of what happened in the previous iteration. False by default. .. versionadded:: 1.1.0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- binary_closing : ndarray of bools Closing of the input by the structuring element. See Also -------- grey_closing, binary_opening, binary_dilation, binary_erosion, generate_binary_structure Notes ----- *Closing* [1]_ is a mathematical morphology operation [2]_ that consists in the succession of a dilation and an erosion of the input with the same structuring element. Closing therefore fills holes smaller than the structuring element. Together with *opening* (`binary_opening`), closing can be used for noise removal. References ---------- .. [1] https://en.wikipedia.org/wiki/Closing_%28morphology%29 .. [2] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((5,5), dtype=int) >>> a[1:-1, 1:-1] = 1; a[2,2] = 0 >>> a array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 0, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) >>> # Closing removes small holes >>> ndimage.binary_closing(a).astype(int) array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) >>> # Closing is the erosion of the dilation of the input >>> ndimage.binary_dilation(a).astype(int) array([[0, 1, 1, 1, 0], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [0, 1, 1, 1, 0]]) >>> ndimage.binary_erosion(ndimage.binary_dilation(a)).astype(int) array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) >>> a = np.zeros((7,7), dtype=int) >>> a[1:6, 2:5] = 1; a[1:3,3] = 0 >>> a array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0], [0, 0, 1, 0, 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]]) >>> # In addition to removing holes, closing can also >>> # coarsen boundaries with fine hollows. >>> ndimage.binary_closing(a).astype(int) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 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]]) >>> ndimage.binary_closing(a, structure=np.ones((2,2))).astype(int) 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]]) Nrrr) rrrrUr8r5rr r rvs r(r r sZ JJu E  " "4 4D4yH-h: %Jd& $ HC #y*dF& $ HHrIc tj|}tj||j}t |}| t |d}ntj|}|tj|}tj||}||}ntj||}t||dddd|dd| }t|tj} t||dd|d|dd| } | r.tj||tj|||ytj| | tj|| S)a Multidimensional binary hit-or-miss transform. The hit-or-miss transform finds the locations of a given pattern inside the input image. Parameters ---------- input : array_like (cast to booleans) Binary image where a pattern is to be detected. structure1 : array_like (cast to booleans), optional Part of the structuring element to be fitted to the foreground (non-zero elements) of `input`. If no value is provided, a structure of square connectivity 1 is chosen. structure2 : array_like (cast to booleans), optional Second part of the structuring element that has to miss completely the foreground. If no value is provided, the complementary of `structure1` is taken. output : ndarray, optional Array of the same shape as input, into which the output is placed. By default, a new array is created. origin1 : int or tuple of ints, optional Placement of the first part of the structuring element `structure1`, by default 0 for a centered structure. origin2 : int or tuple of ints, optional Placement of the second part of the structuring element `structure2`, by default 0 for a centered structure. If a value is provided for `origin1` and not for `origin2`, then `origin2` is set to `origin1`. axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If `origin1` or `origin2` tuples are provided, their length must match the number of axes. Returns ------- binary_hit_or_miss : ndarray Hit-or-miss transform of `input` with the given structuring element (`structure1`, `structure2`). See Also -------- binary_erosion References ---------- .. [1] https://en.wikipedia.org/wiki/Hit-or-miss_transform Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((7,7), dtype=int) >>> a[1, 1] = 1; a[2:4, 2:4] = 1; a[4:6, 4:6] = 1 >>> a array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> structure1 = np.array([[1, 0, 0], [0, 1, 1], [0, 1, 1]]) >>> structure1 array([[1, 0, 0], [0, 1, 1], [0, 1, 1]]) >>> # Find the matches of structure1 in the array a >>> ndimage.binary_hit_or_miss(a, structure1=structure1).astype(int) array([[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, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> # Change the origin of the filter >>> # origin1=1 is equivalent to origin1=(1,1) here >>> ndimage.binary_hit_or_miss(a, structure1=structure1,\ ... origin1=1).astype(int) 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, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0]]) NrrF) rrrrUr8r5r logical_notr7rqr[r\ logical_and) rb structure1 structure2rHorigin1origin2rgritmp1inplaceresults r(r r =s"t JJu E  " "4 4D4yH.x; ZZ + ^^J/ --gx@G11'8D 5*atQeT +D,G UJ4$a6F vv& tVV, vv&~~dF++rIc (t||d|||||S)ac Multidimensional binary propagation with the given structuring element. Parameters ---------- input : array_like Binary image to be propagated inside `mask`. structure : array_like, optional Structuring element used in the successive dilations. The output may depend on the structuring element, especially if `mask` has several connex components. If no structuring element is provided, an element is generated with a squared connectivity equal to one. mask : array_like, optional Binary mask defining the region into which `input` is allowed to propagate. output : ndarray, optional Array of the same shape as input, into which the output is placed. By default, a new array is created. border_value : int (cast to 0 or 1), optional Value at the border in the output array. origin : int or tuple of ints, optional Placement of the filter, by default 0. axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- binary_propagation : ndarray Binary propagation of `input` inside `mask`. Notes ----- This function is functionally equivalent to calling binary_dilation with the number of iterations less than one: iterative dilation until the result does not change anymore. The succession of an erosion and propagation inside the original image can be used instead of an *opening* for deleting small objects while keeping the contours of larger objects untouched. References ---------- .. [1] http://cmm.ensmp.fr/~serra/cours/pdf/en/ch6en.pdf, slide 15. .. [2] I.T. Young, J.J. Gerbrands, and L.J. van Vliet, "Fundamentals of image processing", 1998 ftp://qiftp.tudelft.nl/DIPimage/docs/FIP2.3.pdf Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> input = np.zeros((8, 8), dtype=int) >>> input[2, 2] = 1 >>> mask = np.zeros((8, 8), dtype=int) >>> mask[1:4, 1:4] = mask[4, 4] = mask[6:8, 6:8] = 1 >>> input array([[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, 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, 0, 0, 0, 0, 0, 0]]) >>> mask array([[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 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, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]) >>> ndimage.binary_propagation(input, mask=mask).astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 1, 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, 0, 0, 0, 0, 0]]) >>> ndimage.binary_propagation(input, mask=mask,\ ... structure=np.ones((3,3))).astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 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, 0, 0, 0, 0, 0]]) >>> # Comparison between opening and erosion+propagation >>> a = np.zeros((6,6), dtype=int) >>> a[2:5, 2:5] = 1; a[0, 0] = 1; a[5, 5] = 1 >>> a array([[1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1]]) >>> ndimage.binary_opening(a).astype(int) array([[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 1, 1, 1, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0]]) >>> b = ndimage.binary_erosion(a) >>> b.astype(int) array([[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], [0, 0, 0, 0, 0, 0]]) >>> ndimage.binary_propagation(b, mask=a).astype(int) array([[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0]]) rLrr)r )rbr#rcrHrdr$rgs r(rrs#H 5)Rv'd <>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((5, 5), dtype=int) >>> a[1:4, 1:4] = 1 >>> a[2,2] = 0 >>> a array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 0, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) >>> ndimage.binary_fill_holes(a).astype(int) array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) >>> # Too big structuring element >>> ndimage.binary_fill_holes(a, structure=np.ones((5,5))).astype(int) array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 0, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]) rLrrrN) rrrzr6r!r"r[r\r )rbr#rHr$rgrcrwrs r(rr;sZ JJu E >>% D ((4::t $C,GYD&!V$O vv& iT4!'d4 vv& rIc b|| | tdtj||||||||d| S)a Calculate a greyscale erosion, using either a structuring element, or a footprint corresponding to a flat structuring element. Grayscale erosion is a mathematical morphology operation. For the simple case of a full and flat structuring element, it can be viewed as a minimum filter over a sliding window. Parameters ---------- input : array_like Array over which the grayscale erosion is to be computed. size : tuple of ints Shape of a flat and full structuring element used for the grayscale erosion. Optional if `footprint` or `structure` is provided. footprint : array of ints, optional Positions of non-infinite elements of a flat structuring element used for the grayscale erosion. Non-zero values give the set of neighbors of the center over which the minimum is chosen. structure : array of ints, optional Structuring element used for the grayscale erosion. `structure` may be a non-flat structuring element. The `structure` array applies a subtractive offset for each pixel in the neighborhood. output : array, optional An array used for storing the output of the erosion may be provided. mode : {'reflect','constant','nearest','mirror', 'wrap'}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to 'constant'. Default is 'reflect' cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0. origin : scalar, optional The `origin` parameter controls the placement of the filter. Default 0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- output : ndarray Grayscale erosion of `input`. See Also -------- binary_erosion, grey_dilation, grey_opening, grey_closing generate_binary_structure, minimum_filter Notes ----- The grayscale erosion of an image input by a structuring element s defined over a domain E is given by: (input+s)(x) = min {input(y) - s(x-y), for y in E} In particular, for structuring elements defined as s(y) = 0 for y in E, the grayscale erosion computes the minimum of the input image inside a sliding window defined by E. Grayscale erosion [1]_ is a *mathematical morphology* operation [2]_. References ---------- .. [1] https://en.wikipedia.org/wiki/Erosion_%28morphology%29 .. [2] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((7,7), dtype=int) >>> a[1:6, 1:6] = 3 >>> a[4,4] = 2; a[2,3] = 1 >>> a array([[0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 3, 3, 0], [0, 3, 3, 1, 3, 3, 0], [0, 3, 3, 3, 3, 3, 0], [0, 3, 3, 3, 2, 3, 0], [0, 3, 3, 3, 3, 3, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> ndimage.grey_erosion(a, size=(3,3)) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 3, 2, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> footprint = ndimage.generate_binary_structure(2, 1) >>> footprint array([[False, True, False], [ True, True, True], [False, True, False]], dtype=bool) >>> # Diagonally-connected elements are not considered neighbors >>> ndimage.grey_erosion(a, footprint=footprint) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 3, 1, 2, 0, 0], [0, 0, 3, 2, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) /size, footprint, or structure must be specifiedrrr) ValueErrorr_min_or_max_filter) rbrY footprintr#rHmodecvalr$rgs r(rrsI\ | )i.?JKK  & &udIy'-tT61,0 22rIc || | td|>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((7,7), dtype=int) >>> a[2:5, 2:5] = 1 >>> a[4,4] = 2; a[2,3] = 3 >>> a array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 3, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> ndimage.grey_dilation(a, size=(3,3)) array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 3, 3, 3, 2, 0], [0, 1, 1, 2, 2, 2, 0], [0, 1, 1, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> ndimage.grey_dilation(a, footprint=np.ones((3,3))) array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 3, 3, 3, 2, 0], [0, 1, 1, 2, 2, 2, 0], [0, 1, 1, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> s = ndimage.generate_binary_structure(2,1) >>> s array([[False, True, False], [ True, True, True], [False, True, False]], dtype=bool) >>> ndimage.grey_dilation(a, footprint=s) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 3, 1, 0, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 1, 3, 2, 1, 0], [0, 1, 1, 2, 2, 2, 0], [0, 0, 1, 1, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> ndimage.grey_dilation(a, size=(3,3), structure=np.ones((3,3))) array([[1, 1, 1, 1, 1, 1, 1], [1, 2, 4, 4, 4, 2, 1], [1, 2, 4, 4, 4, 2, 1], [1, 2, 4, 4, 4, 3, 1], [1, 2, 2, 3, 3, 3, 1], [1, 2, 2, 3, 3, 3, 1], [1, 1, 1, 1, 1, 1, 1]]) NrrLrrrr)rrrrr-r8rrUr7r5r4r!isscalarrr) rbrYrr#rHrrr$rgr/szs r(rr sz | )i.?JKKJJy) eU4r%:$;$-NN%345 JJy) eU4r%:$;$-NN%345  JJu E  " "4 4D  , ,VSY ?FCK Rj[r  $B  "$B [[ BbBAv 2J!OJ   & &udIy'-tT61,0 22rIc ||tjdtdt||||d|||| } t | |||||||| S)a Multidimensional grayscale opening. A grayscale opening consists in the succession of a grayscale erosion, and a grayscale dilation. Parameters ---------- input : array_like Array over which the grayscale opening is to be computed. size : tuple of ints Shape of a flat and full structuring element used for the grayscale opening. Optional if `footprint` or `structure` is provided. footprint : array of ints, optional Positions of non-infinite elements of a flat structuring element used for the grayscale opening. structure : array of ints, optional Structuring element used for the grayscale opening. `structure` may be a non-flat structuring element. The `structure` array applies offsets to the pixels in a neighborhood (the offset is additive during dilation and subtractive during erosion). output : array, optional An array used for storing the output of the opening may be provided. mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to 'constant'. Default is 'reflect' cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0. origin : scalar, optional The `origin` parameter controls the placement of the filter. Default 0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- grey_opening : ndarray Result of the grayscale opening of `input` with `structure`. See Also -------- binary_opening, grey_dilation, grey_erosion, grey_closing generate_binary_structure Notes ----- The action of a grayscale opening with a flat structuring element amounts to smoothen high local maxima, whereas binary opening erases small objects. References ---------- .. [1] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.arange(36).reshape((6,6)) >>> a[3, 3] = 50 >>> a array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 50, 22, 23], [24, 25, 26, 27, 28, 29], [30, 31, 32, 33, 34, 35]]) >>> ndimage.grey_opening(a, size=(3,3)) array([[ 0, 1, 2, 3, 4, 4], [ 6, 7, 8, 9, 10, 10], [12, 13, 14, 15, 16, 16], [18, 19, 20, 22, 22, 22], [24, 25, 26, 27, 28, 28], [24, 25, 26, 27, 28, 28]]) >>> # Note that the local maximum a[3,3] has disappeared N&ignoring size because footprint is setr stacklevelrr)warningswarn UserWarningrr rbrYrr#rHrrr$rgrws r(rrsaf y4 >!a 1 udIy$V$ 0C dIy&$vD 22rIc ||tjdtdt||||d|||| } t | |||||||| S)a| Multidimensional grayscale closing. A grayscale closing consists in the succession of a grayscale dilation, and a grayscale erosion. Parameters ---------- input : array_like Array over which the grayscale closing is to be computed. size : tuple of ints Shape of a flat and full structuring element used for the grayscale closing. Optional if `footprint` or `structure` is provided. footprint : array of ints, optional Positions of non-infinite elements of a flat structuring element used for the grayscale closing. structure : array of ints, optional Structuring element used for the grayscale closing. `structure` may be a non-flat structuring element. The `structure` array applies offsets to the pixels in a neighborhood (the offset is additive during dilation and subtractive during erosion) output : array, optional An array used for storing the output of the closing may be provided. mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to 'constant'. Default is 'reflect' cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0. origin : scalar, optional The `origin` parameter controls the placement of the filter. Default 0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- grey_closing : ndarray Result of the grayscale closing of `input` with `structure`. See Also -------- binary_closing, grey_dilation, grey_erosion, grey_opening, generate_binary_structure Notes ----- The action of a grayscale closing with a flat structuring element amounts to smoothen deep local minima, whereas binary closing fills small holes. References ---------- .. [1] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.arange(36).reshape((6,6)) >>> a[3,3] = 0 >>> a array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 0, 22, 23], [24, 25, 26, 27, 28, 29], [30, 31, 32, 33, 34, 35]]) >>> ndimage.grey_closing(a, size=(3,3)) array([[ 7, 7, 8, 9, 10, 11], [ 7, 7, 8, 9, 10, 11], [13, 13, 14, 15, 16, 17], [19, 19, 20, 20, 22, 23], [25, 25, 26, 27, 28, 29], [31, 31, 32, 33, 34, 35]]) >>> # Note that the local minimum a[3,3] has disappeared Nrrrrr)rrrrrrs r(rrsaf y4 >!a 1 tY 4f4 1C T9if4 11rIc t||||d|||| } t|tjr+t ||||||||| tj | ||S| t ||||d|||| z S)a Multidimensional morphological gradient. The morphological gradient is calculated as the difference between a dilation and an erosion of the input with a given structuring element. Parameters ---------- input : array_like Array over which to compute the morphlogical gradient. size : tuple of ints Shape of a flat and full structuring element used for the mathematical morphology operations. Optional if `footprint` or `structure` is provided. A larger `size` yields a more blurred gradient. footprint : array of ints, optional Positions of non-infinite elements of a flat structuring element used for the morphology operations. Larger footprints give a more blurred morphological gradient. structure : array of ints, optional Structuring element used for the morphology operations. `structure` may be a non-flat structuring element. The `structure` array applies offsets to the pixels in a neighborhood (the offset is additive during dilation and subtractive during erosion) output : array, optional An array used for storing the output of the morphological gradient may be provided. mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to 'constant'. Default is 'reflect' cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0. origin : scalar, optional The `origin` parameter controls the placement of the filter. Default 0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- morphological_gradient : ndarray Morphological gradient of `input`. See Also -------- grey_dilation, grey_erosion, gaussian_gradient_magnitude Notes ----- For a flat structuring element, the morphological gradient computed at a given point corresponds to the maximal difference between elements of the input among the elements covered by the structuring element centered on the point. References ---------- .. [1] https://en.wikipedia.org/wiki/Mathematical_morphology Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.zeros((7,7), dtype=int) >>> a[2:5, 2:5] = 1 >>> ndimage.morphological_gradient(a, size=(3,3)) array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 1, 1, 0, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> # The morphological gradient is computed as the difference >>> # between a dilation and an erosion >>> ndimage.grey_dilation(a, size=(3,3)) -\ ... ndimage.grey_erosion(a, size=(3,3)) array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 1, 1, 0, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> a = np.zeros((7,7), dtype=int) >>> a[2:5, 2:5] = 1 >>> a[4,4] = 2; a[2,3] = 3 >>> a array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 3, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> ndimage.morphological_gradient(a, size=(3,3)) array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 3, 3, 3, 1, 0], [0, 1, 3, 2, 3, 2, 0], [0, 1, 1, 2, 2, 2, 0], [0, 1, 1, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0]]) Nrr)rr[rr\rsubtractrs r(rras\ tY 4f4 1C&"**%UD)Y6 .{{3//l5$ 9#'tV$HH IrIc tj|}t||||d|||| } t|tjrYt ||||||||| tj | ||tj|||tj|||St ||||d|||| } tj | | | tj| || tj| || | S)a] Multidimensional morphological laplace. Parameters ---------- input : array_like Input. size : tuple of ints Shape of a flat and full structuring element used for the mathematical morphology operations. Optional if `footprint` or `structure` is provided. footprint : array of ints, optional Positions of non-infinite elements of a flat structuring element used for the morphology operations. structure : array of ints, optional Structuring element used for the morphology operations. `structure` may be a non-flat structuring element. The `structure` array applies offsets to the pixels in a neighborhood (the offset is additive during dilation and subtractive during erosion) output : ndarray, optional An output array can optionally be provided. mode : {'reflect','constant','nearest','mirror', 'wrap'}, optional The mode parameter determines how the array borders are handled. For 'constant' mode, values beyond borders are set to be `cval`. Default is 'reflect'. cval : scalar, optional Value to fill past edges of input if mode is 'constant'. Default is 0.0 origin : origin, optional The origin parameter controls the placement of the filter. axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- morphological_laplace : ndarray Output Nrr)rrrr[r\rrDr) rbrYrr#rHrrr$rgrtmp2s r(rrsX JJu E iD$vD 2D&"**%UD)Y6 . tVV$ FE6*{{65&11E4ItT &t5 tT4  D%& D%& rIc tj|}||tjdtdt ||||d|||| } t | |||||||| } | |} |jtjk(r7| jtjk(rtj|| | | Stj|| | | S)aU Multidimensional white tophat filter. Parameters ---------- input : array_like Input. size : tuple of ints Shape of a flat and full structuring element used for the filter. Optional if `footprint` or `structure` is provided. footprint : array of ints, optional Positions of elements of a flat structuring element used for the white tophat filter. structure : array of ints, optional Structuring element used for the filter. `structure` may be a non-flat structuring element. The `structure` array applies offsets to the pixels in a neighborhood (the offset is additive during dilation and subtractive during erosion) output : array, optional An array used for storing the output of the filter may be provided. mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to 'constant'. Default is 'reflect' cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0. origin : scalar, optional The `origin` parameter controls the placement of the filter. Default is 0. axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- output : ndarray Result of the filter of `input` with `structure`. See Also -------- black_tophat Examples -------- Subtract gray background from a bright peak. >>> from scipy.ndimage import generate_binary_structure, white_tophat >>> import numpy as np >>> square = generate_binary_structure(rank=2, connectivity=3) >>> bright_on_gray = np.array([[2, 3, 3, 3, 2], ... [3, 4, 5, 4, 3], ... [3, 5, 9, 5, 3], ... [3, 4, 5, 4, 3], ... [2, 3, 3, 3, 2]]) >>> white_tophat(input=bright_on_gray, structure=square) array([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 5, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]) Nrrrrrr;) rrrrrrrr?bool_ bitwise_xorrrs r(rrsF JJu E y4 >!a 1 udIy$V$ 0C T9if4 1C { {{bhh399#8 ucs+ J E3C( JrIc tj|}||tjdtdt ||||d|||| } t | |||||||| } | |} |jtjk(r7| jtjk(rtj| || | Stj| || | S)a Multidimensional black tophat filter. Parameters ---------- input : array_like Input. size : tuple of ints, optional Shape of a flat and full structuring element used for the filter. Optional if `footprint` or `structure` is provided. footprint : array of ints, optional Positions of non-infinite elements of a flat structuring element used for the black tophat filter. structure : array of ints, optional Structuring element used for the filter. `structure` may be a non-flat structuring element. The `structure` array applies offsets to the pixels in a neighborhood (the offset is additive during dilation and subtractive during erosion) output : array, optional An array used for storing the output of the filter may be provided. mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to 'constant'. Default is 'reflect' cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0. origin : scalar, optional The `origin` parameter controls the placement of the filter. Default 0 axes : tuple of int or None The axes over which to apply the filter. If None, `input` is filtered along all axes. If an `origin` tuple is provided, its length must match the number of axes. Returns ------- black_tophat : ndarray Result of the filter of `input` with `structure`. See Also -------- white_tophat, grey_opening, grey_closing Examples -------- Change dark peak to bright peak and subtract background. >>> from scipy.ndimage import generate_binary_structure, black_tophat >>> import numpy as np >>> square = generate_binary_structure(rank=2, connectivity=3) >>> dark_on_gray = np.array([[7, 6, 6, 6, 7], ... [6, 5, 4, 5, 6], ... [6, 4, 0, 4, 6], ... [6, 5, 4, 5, 6], ... [7, 6, 6, 6, 7]]) >>> black_tophat(input=dark_on_gray, structure=square) array([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 5, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]) Nrrrrrr) rrrrrrrr?rrrrs r(rrnsD JJu E y4 >!a 1 tY 4f4 1C sD)YV$ 0C { {{bhh399#8 sEs+ J CC( JrIcpt|tj}t|tj}t||||tj|dk7} t | j | j } t| | } tj| | } | jtj| jtjz } |j}|dk(rd}n|dvrd}n|dk(rd}n td|ktj|| j }tj|tj }|j j"s|j%}|r0tj&| j(tj* } nd } |r|e|dk(r0tj&| j(tj } ntj&| j(tj, } n|j(| j(k7r td |dk(r2|j.j0tjk7r=td |j.j0tj,k7r td |} nd } t3j4| ||| | |rt|tjrg|j.j0tj*k7r td|j(| j f| j(zk7r td|} n/tj6| j(tj* } tj8| } t;| j(dD]7}tj8| |df| }| j(|_|| |df<9| } g}|r|s|j=| |r|s|j=| t?|dk(r tA|St?|dk(r|dSy )a Distance transform function by a brute force algorithm. This function calculates the distance transform of the `input`, by replacing each foreground (non-zero) element, with its shortest distance to the background (any zero-valued element). In addition to the distance transform, the feature transform can be calculated. In this case the index of the closest background element to each foreground element is returned in a separate array. Parameters ---------- input : array_like Input metric : {'euclidean', 'taxicab', 'chessboard'}, optional 'cityblock' and 'manhattan' are also valid, and map to 'taxicab'. The default is 'euclidean'. sampling : float, or sequence of float, optional This parameter is only used when `metric` is 'euclidean'. Spacing of elements along each dimension. If a sequence, must be of length equal to the input rank; if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied. return_distances : bool, optional Whether to calculate the distance transform. Default is True. return_indices : bool, optional Whether to calculate the feature transform. Default is False. distances : ndarray, optional An output array to store the calculated distance transform, instead of returning it. `return_distances` must be True. It must be the same shape as `input`, and of type float64 if `metric` is 'euclidean', uint32 otherwise. indices : int32 ndarray, optional An output array to store the calculated feature transform, instead of returning it. `return_indicies` must be True. Its shape must be ``(input.ndim,) + input.shape``. Returns ------- distances : ndarray, optional The calculated distance transform. Returned only when `return_distances` is True and `distances` is not supplied. It will have the same shape as the input array. indices : int32 ndarray, optional The calculated feature transform. It has an input-shaped array for each dimension of the input. See distance_transform_edt documentation for an example. Returned only when `return_indices` is True and `indices` is not supplied. See Also -------- distance_transform_cdt : Faster distance transform for taxicab and chessboard metrics distance_transform_edt : Faster distance transform for euclidean metric Notes ----- This function employs a slow brute force algorithm. See also the function `distance_transform_cdt` for more efficient taxicab [1]_ and chessboard algorithms [2]_. References ---------- .. [1] Taxicab distance. Wikipedia, 2023. https://en.wikipedia.org/wiki/Taxicab_geometry .. [2] Chessboard distance. Wikipedia, 2023. https://en.wikipedia.org/wiki/Chebyshev_distance Examples -------- Import the necessary modules. >>> import numpy as np >>> from scipy.ndimage import distance_transform_bf >>> import matplotlib.pyplot as plt >>> from mpl_toolkits.axes_grid1 import ImageGrid First, we create a toy binary image. >>> def add_circle(center_x, center_y, radius, image, fillvalue=1): ... # fill circular area with 1 ... xx, yy = np.mgrid[:image.shape[0], :image.shape[1]] ... circle = (xx - center_x) ** 2 + (yy - center_y) ** 2 ... circle_shape = np.sqrt(circle) < radius ... image[circle_shape] = fillvalue ... return image >>> image = np.zeros((100, 100), dtype=np.uint8) >>> image[35:65, 20:80] = 1 >>> image = add_circle(28, 65, 10, image) >>> image = add_circle(37, 30, 10, image) >>> image = add_circle(70, 45, 20, image) >>> image = add_circle(45, 80, 10, image) Next, we set up the figure. >>> fig = plt.figure(figsize=(8, 8)) # set up the figure structure >>> grid = ImageGrid(fig, 111, nrows_ncols=(2, 2), axes_pad=(0.4, 0.3), ... label_mode="1", share_all=True, ... cbar_location="right", cbar_mode="each", ... cbar_size="7%", cbar_pad="2%") >>> for ax in grid: ... ax.axis('off') # remove axes from images The top left image is the original binary image. >>> binary_image = grid[0].imshow(image, cmap='gray') >>> cbar_binary_image = grid.cbar_axes[0].colorbar(binary_image) >>> cbar_binary_image.set_ticks([0, 1]) >>> grid[0].set_title("Binary image: foreground in white") The distance transform calculates the distance between foreground pixels and the image background according to a distance metric. Available metrics in `distance_transform_bf` are: ``euclidean`` (default), ``taxicab`` and ``chessboard``. The top right image contains the distance transform based on the ``euclidean`` metric. >>> distance_transform_euclidean = distance_transform_bf(image) >>> euclidean_transform = grid[1].imshow(distance_transform_euclidean, ... cmap='gray') >>> cbar_euclidean = grid.cbar_axes[1].colorbar(euclidean_transform) >>> colorbar_ticks = [0, 10, 20] >>> cbar_euclidean.set_ticks(colorbar_ticks) >>> grid[1].set_title("Euclidean distance") The lower left image contains the distance transform using the ``taxicab`` metric. >>> distance_transform_taxicab = distance_transform_bf(image, ... metric='taxicab') >>> taxicab_transformation = grid[2].imshow(distance_transform_taxicab, ... cmap='gray') >>> cbar_taxicab = grid.cbar_axes[2].colorbar(taxicab_transformation) >>> cbar_taxicab.set_ticks(colorbar_ticks) >>> grid[2].set_title("Taxicab distance") Finally, the lower right image contains the distance transform using the ``chessboard`` metric. >>> distance_transform_cb = distance_transform_bf(image, ... metric='chessboard') >>> chessboard_transformation = grid[3].imshow(distance_transform_cb, ... cmap='gray') >>> cbar_taxicab = grid.cbar_axes[3].colorbar(chessboard_transformation) >>> cbar_taxicab.set_ticks(colorbar_ticks) >>> grid[3].set_title("Chessboard distance") >>> plt.show() r euclideanrtaxicab cityblock manhattanr chessboardr@zdistance metric not supportedNr>distances array has wrong shapedistances array must be float64zdistances array must be uint32indices array must be int32indices array has wrong shape.)!r[rr\_distance_tranform_arg_checkrrr8r logical_xorastyper_lowerrWrr7float64rPrXr3r6r!int32uint32r?typerrrCravelr4appendr5r)rbmetricsamplingreturn_distancesreturn_indices distancesrC ft_inplace dt_inplacerstructrftdtr/rtmprs r(rrs@xGRZZ0JIrzz2J J 0. ::e  !D &tyy$)) >$ %D ;;rww $++bgg"6 6D \\^F  8 8 < :;;228TYYG::hbjj9~~((}}H XXdjj 1   {XXdjj ;XXdjj :$**,"#DEE{??''2::5&'HII??''2994&'GHHB  ##D&(BC grzz *}}!!RXX-"#@AA}} tzz 99"#BCCD::djj9D XXb\ 1 & !B88DSM*2.DDJ DSM !F  bj b 6{aV} V ayrIct|tj}t|tj}t||||tj|}t|t rF|dvr|j }t|d}n`|dk(r|j }t||}nBtd tj|}|jD]} | dk7s td|jjs|j}|r|jjtj k7r td|j|jk7r td |} tj"|d d j%tj | d <n4tj"|d d j%tj } | j }|rAtj&| j(tj } | j| _ nd} t+j,|| | | t/t1ddd g|z} |r| t/t1ddd g|z} t+j,|| | | t/t1ddd g|z} |r| t/t1ddd g|z} tj2| } |rg|jjtj k7r td|j| j f| jzk7r td|} n/tj4| jtj } t7| jd D]7}tj2| |d f| }| j|_ || |d f<9| } g}|r|s|j9| |r|s|j9| t;|dk(r t/|St;|dk(r|d Sy#t$r} td| d} ~ wwxYw)aN Distance transform for chamfer type of transforms. This function calculates the distance transform of the `input`, by replacing each foreground (non-zero) element, with its shortest distance to the background (any zero-valued element). In addition to the distance transform, the feature transform can be calculated. In this case the index of the closest background element to each foreground element is returned in a separate array. Parameters ---------- input : array_like Input. Values of 0 are treated as background. metric : {'chessboard', 'taxicab'} or array_like, optional The `metric` determines the type of chamfering that is done. If the `metric` is equal to 'taxicab' a structure is generated using `generate_binary_structure` with a squared distance equal to 1. If the `metric` is equal to 'chessboard', a `metric` is generated using `generate_binary_structure` with a squared distance equal to the dimensionality of the array. These choices correspond to the common interpretations of the 'taxicab' and the 'chessboard' distance metrics in two dimensions. A custom metric may be provided, in the form of a matrix where each dimension has a length of three. 'cityblock' and 'manhattan' are also valid, and map to 'taxicab'. The default is 'chessboard'. return_distances : bool, optional Whether to calculate the distance transform. Default is True. return_indices : bool, optional Whether to calculate the feature transform. Default is False. distances : int32 ndarray, optional An output array to store the calculated distance transform, instead of returning it. `return_distances` must be True. It must be the same shape as `input`. indices : int32 ndarray, optional An output array to store the calculated feature transform, instead of returning it. `return_indicies` must be True. Its shape must be ``(input.ndim,) + input.shape``. Returns ------- distances : int32 ndarray, optional The calculated distance transform. Returned only when `return_distances` is True, and `distances` is not supplied. It will have the same shape as the input array. indices : int32 ndarray, optional The calculated feature transform. It has an input-shaped array for each dimension of the input. See distance_transform_edt documentation for an example. Returned only when `return_indices` is True, and `indices` is not supplied. See Also -------- distance_transform_edt : Fast distance transform for euclidean metric distance_transform_bf : Distance transform for different metrics using a slower brute force algorithm Examples -------- Import the necessary modules. >>> import numpy as np >>> from scipy.ndimage import distance_transform_cdt >>> import matplotlib.pyplot as plt >>> from mpl_toolkits.axes_grid1 import ImageGrid First, we create a toy binary image. >>> def add_circle(center_x, center_y, radius, image, fillvalue=1): ... # fill circular area with 1 ... xx, yy = np.mgrid[:image.shape[0], :image.shape[1]] ... circle = (xx - center_x) ** 2 + (yy - center_y) ** 2 ... circle_shape = np.sqrt(circle) < radius ... image[circle_shape] = fillvalue ... return image >>> image = np.zeros((100, 100), dtype=np.uint8) >>> image[35:65, 20:80] = 1 >>> image = add_circle(28, 65, 10, image) >>> image = add_circle(37, 30, 10, image) >>> image = add_circle(70, 45, 20, image) >>> image = add_circle(45, 80, 10, image) Next, we set up the figure. >>> fig = plt.figure(figsize=(5, 15)) >>> grid = ImageGrid(fig, 111, nrows_ncols=(3, 1), axes_pad=(0.5, 0.3), ... label_mode="1", share_all=True, ... cbar_location="right", cbar_mode="each", ... cbar_size="7%", cbar_pad="2%") >>> for ax in grid: ... ax.axis('off') >>> top, middle, bottom = grid >>> colorbar_ticks = [0, 10, 20] The top image contains the original binary image. >>> binary_image = top.imshow(image, cmap='gray') >>> cbar_binary_image = top.cax.colorbar(binary_image) >>> cbar_binary_image.set_ticks([0, 1]) >>> top.set_title("Binary image: foreground in white") The middle image contains the distance transform using the ``taxicab`` metric. >>> distance_taxicab = distance_transform_cdt(image, metric="taxicab") >>> taxicab_transform = middle.imshow(distance_taxicab, cmap='gray') >>> cbar_taxicab = middle.cax.colorbar(taxicab_transform) >>> cbar_taxicab.set_ticks(colorbar_ticks) >>> middle.set_title("Taxicab metric") The bottom image contains the distance transform using the ``chessboard`` metric. >>> distance_chessboard = distance_transform_cdt(image, ... metric="chessboard") >>> chessboard_transform = bottom.imshow(distance_chessboard, cmap='gray') >>> cbar_chessboard = bottom.cax.colorbar(chessboard_transform) >>> cbar_chessboard.set_ticks(colorbar_ticks) >>> bottom.set_title("Chessboard metric") >>> plt.tight_layout() >>> plt.show() rrrzinvalid metric providedNr@zmetric sizes must be equal to 3zdistances must be of int32 typezdistances has wrong shaperLr.r>rrr)r[rr\rrstrr8rr Exceptionr!rPrXr3r?rrwhererarangerYrdistance_transform_oprr-rrCr4rr5)rbrrrrrCrrrFrhsrrrwr/rrs r(rrsHGRZZ0JIrzz2J J 0. JJu E&# : :::D.tQ7F | #::D.tT:F67 7 ?ZZ'F DAAv !BCC D << " " ??  288 +>? ? ??ekk )89 9 ((5"a(//93 XXeR # * *288 4 77D YYrwwbhh /88  ##FB3 E5tR()D0 1 2B uT4,-45 6 ##FB3 E5tR()D0 1 2B uT4,-45 6 XXb\ }}!!RXX- !>??}} RXX 55 !@AAC**RXXRXX6C ! % B88CCL)"-DDJCCL F  bj b 6{aV} V ayy ?67Q > ?s/P## P=, P88P=ct|tj}t|tj}t||||tjtj |ddj tj}|ktj||j}tj|tj}|jjs|j}|rf|}|j |jf|j zk7r t#d|j$j&tj(k7rHt#dtj*|jf|j ztj(}t-j.||||rW|tj0|j |j$z } | j tj} |+t3t5|D]} | | dfxx|| zcc<tj6| | | |rtj8j;| d} |j | j k7r t#d |j$j&tjk7r t#d tj<| |n6tj8j;| d} tj<| } g} |r|s| j? |r|s| j?|t5| d k(r tA| St5| dk(r| dSy) af Exact Euclidean distance transform. This function calculates the distance transform of the `input`, by replacing each foreground (non-zero) element, with its shortest distance to the background (any zero-valued element). In addition to the distance transform, the feature transform can be calculated. In this case the index of the closest background element to each foreground element is returned in a separate array. Parameters ---------- input : array_like Input data to transform. Can be any type but will be converted into binary: 1 wherever input equates to True, 0 elsewhere. sampling : float, or sequence of float, optional Spacing of elements along each dimension. If a sequence, must be of length equal to the input rank; if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied. return_distances : bool, optional Whether to calculate the distance transform. Default is True. return_indices : bool, optional Whether to calculate the feature transform. Default is False. distances : float64 ndarray, optional An output array to store the calculated distance transform, instead of returning it. `return_distances` must be True. It must be the same shape as `input`. indices : int32 ndarray, optional An output array to store the calculated feature transform, instead of returning it. `return_indicies` must be True. Its shape must be ``(input.ndim,) + input.shape``. Returns ------- distances : float64 ndarray, optional The calculated distance transform. Returned only when `return_distances` is True and `distances` is not supplied. It will have the same shape as the input array. indices : int32 ndarray, optional The calculated feature transform. It has an input-shaped array for each dimension of the input. See example below. Returned only when `return_indices` is True and `indices` is not supplied. Notes ----- The Euclidean distance transform gives values of the Euclidean distance:: n y_i = sqrt(sum (x[i]-b[i])**2) i where b[i] is the background point (value 0) with the smallest Euclidean distance to input points x[i], and n is the number of dimensions. Examples -------- >>> from scipy import ndimage >>> import numpy as np >>> a = np.array(([0,1,1,1,1], ... [0,0,1,1,1], ... [0,1,1,1,1], ... [0,1,1,1,0], ... [0,1,1,0,0])) >>> ndimage.distance_transform_edt(a) array([[ 0. , 1. , 1.4142, 2.2361, 3. ], [ 0. , 0. , 1. , 2. , 2. ], [ 0. , 1. , 1.4142, 1.4142, 1. ], [ 0. , 1. , 1.4142, 1. , 0. ], [ 0. , 1. , 1. , 0. , 0. ]]) With a sampling of 2 units along x, 1 along y: >>> ndimage.distance_transform_edt(a, sampling=[2,1]) array([[ 0. , 1. , 2. , 2.8284, 3.6056], [ 0. , 0. , 1. , 2. , 3. ], [ 0. , 1. , 2. , 2.2361, 2. ], [ 0. , 1. , 2. , 1. , 0. ], [ 0. , 1. , 1. , 0. , 0. ]]) Asking for indices as well: >>> edt, inds = ndimage.distance_transform_edt(a, return_indices=True) >>> inds array([[[0, 0, 1, 1, 3], [1, 1, 1, 1, 3], [2, 2, 1, 3, 3], [3, 3, 4, 4, 3], [4, 4, 4, 4, 4]], [[0, 0, 1, 1, 4], [0, 1, 1, 1, 4], [0, 0, 1, 4, 4], [0, 0, 3, 3, 4], [0, 0, 3, 3, 4]]], dtype=int32) With arrays provided for inplace outputs: >>> indices = np.zeros(((np.ndim(a),) + a.shape), dtype=np.int32) >>> ndimage.distance_transform_edt(a, return_indices=True, indices=indices) array([[ 0. , 1. , 1.4142, 2.2361, 3. ], [ 0. , 0. , 1. , 2. , 2. ], [ 0. , 1. , 1.4142, 1.4142, 1. ], [ 0. , 1. , 1.4142, 1. , 0. ], [ 0. , 1. , 1. , 0. , 0. ]]) >>> indices array([[[0, 0, 1, 1, 3], [1, 1, 1, 1, 3], [2, 2, 1, 3, 3], [3, 3, 4, 4, 3], [4, 4, 4, 4, 4]], [[0, 0, 1, 1, 4], [0, 1, 1, 1, 4], [0, 0, 1, 4, 4], [0, 0, 3, 3, 4], [0, 0, 3, 3, 4]]], dtype=int32) rrNr>rr.)axisrrr)!r[rr\r atleast_1drrr_rr7r8rrrPrXr3r!rWr?rrr6reuclidean_feature_transformrCr4r5multiplyrDrEsqrtrr) rbrrrrrCrrrrr/rs r(rr s|GRZZ0JIrzz2J J 0. MM"((5!Q/66rww? @E228UZZH::hbjj9~~((}}H  88 }u{{2 2>? ? 88==BHH $<= = XXuzzmekk1 B ))%2> "**U[[9 9 YYrzz "  CM* ,2s7 x|+  , BB r*B"((*"#DEE##rzz1"#DEE GGB "r*BBF  bj b 6{aV} V ayrIcg}|s|s|jd|r|s|jd|r|s|jd|rtdj|y)z1Raise a RuntimeError if the arguments are invalidzNO499Z011rIr,)NrNNrrF)NrNrNrF)NNNrN)NNNrr)NNr)NNNNreflectgr)rNTFNN)rTFNN)NTFNN) rrMnumpyrrrr__all__r)rrrqr r r r r rrrrrrrrrrrrrrrIr(rs> %!BJY"xVrKO9>cOHLcOL?C89 %HO/3HOV@DDIIID@DDIVHVHr;?7;s,EIs,l48;<EB?@s2s2l?C@AZ2Z2z>B?@Y2Y2x>B?@Y1Y1xHLIJvI $vIrGKHI;#;|>B?@SSlKO23R=ARj?C@E26iXIMIMRjCGIMup2rI