| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/ndimage/__pycache__/ |
Upload File : |
�
d�c� � � � d dl Z d dl ZddlmZ ddlmZ ddlmZ ddlmZ g d�Zd d�Zd d �Z dd
�d �Z
d!d
�Z d� Z d"d�Z
d d�Zd d�Zd d�Zd d�Zd d�Z d#d�Zd d�Zd d�Zd d�Zd d�Zd d�Zd d�Zd d �Zd d �Zd d �Z dS )$� N� )� _ni_support)� _ni_label)� _nd_image)� _morphology)�label� find_objects�labeled_comprehension�sum�mean�variance�standard_deviation�minimum�maximum�median�minimum_position�maximum_position�extrema�center_of_mass� histogram�
watershed_ift�
sum_labels�
value_indicesc �n � t j | � � } t j | � � rt d� � �|�t j | j d� � }t j |t �� � }|j | j k rt d� � �|j D ]}|dk rt d� � ��| j dk }t |t j
� � r"|j | j k rt d � � �d
}nQd }|�3t j | j |r t j n t j � � }nt j | j |� � }| j d k s | j d k r%| j d k r| d k rdnd }||d
< nd }|r|S ||fS t% j | ||� � }n�# t$ j $ r�}t j | j |r t j n t j � � } t% j | || � � }| d
|d
< t j || k � � st d� � |�Y d}~nd}~ww xY w|r|S ||fS )a�
Label features in an array.
Parameters
----------
input : array_like
An array-like object to be labeled. Any non-zero values in `input` are
counted as features and zero values are considered the background.
structure : array_like, optional
A structuring element that defines feature connections.
`structure` must be centrosymmetric
(see Notes).
If no structuring element is provided,
one is automatically generated with a squared connectivity equal to
one. That is, for a 2-D `input` array, the default structuring element
is::
[[0,1,0],
[1,1,1],
[0,1,0]]
output : (None, data-type, array_like), optional
If `output` is a data type, it specifies the type of the resulting
labeled feature array.
If `output` is an array-like object, then `output` will be updated
with the labeled features from this function. This function can
operate in-place, by passing output=input.
Note that the output must be able to store the largest label, or this
function will raise an Exception.
Returns
-------
label : ndarray or int
An integer ndarray where each unique feature in `input` has a unique
label in the returned array.
num_features : int
How many objects were found.
If `output` is None, this function returns a tuple of
(`labeled_array`, `num_features`).
If `output` is a ndarray, then it will be updated with values in
`labeled_array` and only `num_features` will be returned by this
function.
See Also
--------
find_objects : generate a list of slices for the labeled features (or
objects); useful for finding features' position or
dimensions
Notes
-----
A centrosymmetric matrix is a matrix that is symmetric about the center.
See [1]_ for more information.
The `structure` matrix must be centrosymmetric to ensure
two-way connections.
For instance, if the `structure` matrix is not centrosymmetric
and is defined as::
[[0,1,0],
[1,1,0],
[0,0,0]]
and the `input` is::
[[1,2],
[0,3]]
then the structure matrix would indicate the
entry 2 in the input is connected to 1,
but 1 is not connected to 2.
Examples
--------
Create an image with some features, then label it using the default
(cross-shaped) structuring element:
>>> from scipy.ndimage import label, generate_binary_structure
>>> import numpy as np
>>> a = np.array([[0,0,1,1,0,0],
... [0,0,0,1,0,0],
... [1,1,0,0,1,0],
... [0,0,0,1,0,0]])
>>> labeled_array, num_features = label(a)
Each of the 4 features are labeled with a different integer:
>>> num_features
4
>>> labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 3, 0],
[0, 0, 0, 4, 0, 0]])
Generate a structuring element that will consider features connected even
if they touch diagonally:
>>> s = generate_binary_structure(2,2)
or,
>>> s = [[1,1,1],
... [1,1,1],
... [1,1,1]]
Label the image using the new structuring element:
>>> labeled_array, num_features = label(a, structure=s)
Show the 2 labeled features (note that features 1, 3, and 4 from above are
now considered a single feature):
>>> num_features
2
>>> labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0]])
References
----------
.. [1] James R. Weaver, "Centrosymmetric (cross-symmetric)
matrices, their basic properties, eigenvalues, and
eigenvectors." The American Mathematical Monthly 92.10
(1985): 711-717.
�Complex type not supportedNr ��dtype�(structure and input must have equal rank� �'structure dimensions must be equal to 3i���zoutput shape not correctTFr .z/insufficient bit-depth in requested output type)�numpy�asarray� iscomplexobj� TypeErrorr �generate_binary_structure�ndim�bool� RuntimeError�shape�
ValueError�size�
isinstance�ndarray�np�empty�intp�int32r �_label� NeedMoreBits�all)
�input� structure�output�ii� need_64bits�caller_provided_output�maxlabel� max_label�e�
tmp_outputs
�=/usr/lib/python3/dist-packages/scipy/ndimage/_measurements.pyr r , s{ � �J
�M�%� � �E� ��%� � � 6��4�5�5�5��� �9�%�*�a�H�H� ��
�i�t�4�4�4�I��~���#�#��E�F�F�F��o� H� H��
��7�7� � F�G�G� G� � �*��+�K��&�%�-�(�(� 3� �<�5�;� &� &� � 7�8�8� 8�!%� � �!&� � �>��X�e�k�k�+O�2�7�7�r�x�P�P�F�F��X�e�k�6�2�2�F�
�z�Q���%�*��/�/� �:��?�?� "�a�Z�Z�q�q�a�H�"�F�3�K�K� �H� !� $��O��8�#� #� � �$�U�I�v�>�>� � �� � !�
�
�
� �X�e�k�k�+O�2�7�7�r�x�P�P�
� �$�U�I�z�B�B� � ��o��s� ��v�f�
�*�+�+� � �A�� ��
� � � � � �����
���� � !����y� � s �F �H,�'A;H'�'H,c �� � t j | � � } t j | � � rt d� � �|dk r| � � � }t j | |� � S )a
Find objects in a labeled array.
Parameters
----------
input : ndarray of ints
Array containing objects defined by different labels. Labels with
value 0 are ignored.
max_label : int, optional
Maximum label to be searched for in `input`. If max_label is not
given, the positions of all objects are returned.
Returns
-------
object_slices : list of tuples
A list of tuples, with each tuple containing N slices (with N the
dimension of the input array). Slices correspond to the minimal
parallelepiped that contains the object. If a number is missing,
None is returned instead of a slice.
See Also
--------
label, center_of_mass
Notes
-----
This function is very useful for isolating a volume of interest inside
a 3-D array, that cannot be "seen through".
Examples
--------
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.zeros((6,6), dtype=int)
>>> a[2:4, 2:4] = 1
>>> a[4, 4] = 1
>>> a[:2, :3] = 2
>>> a[0, 5] = 3
>>> a
array([[2, 2, 2, 0, 0, 3],
[2, 2, 2, 0, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0]])
>>> ndimage.find_objects(a)
[(slice(2, 5, None), slice(2, 5, None)), (slice(0, 2, None), slice(0, 3, None)), (slice(0, 1, None), slice(5, 6, None))]
>>> ndimage.find_objects(a, max_label=2)
[(slice(2, 5, None), slice(2, 5, None)), (slice(0, 2, None), slice(0, 3, None))]
>>> ndimage.find_objects(a == 1, max_label=2)
[(slice(2, 5, None), slice(2, 5, None)), None]
>>> loc = ndimage.find_objects(a)[0]
>>> a[loc]
array([[1, 1, 0],
[1, 1, 0],
[0, 0, 1]])
r r )r! r" r# r$ �maxr r )r5 r< s r? r r � s_ � �x
�M�%� � �E� ��%� � � 6��4�5�5�5��1�}�}��I�I�K�K� � � !�%�� 3� 3�3� )� ignore_valuec � � t j d| j �� � }|du }|s |j � |� � |d< t j | ||� � }|S )a@
Find indices of each distinct value in given array.
Parameters
----------
arr : ndarray of ints
Array containing integer values.
ignore_value : int, optional
This value will be ignored in searching the `arr` array. If not
given, all values found will be included in output. Default
is None.
Returns
-------
indices : dictionary
A Python dictionary of array indices for each distinct value. The
dictionary is keyed by the distinct values, the entries are array
index tuples covering all occurrences of the value within the
array.
This dictionary can occupy significant memory, usually several times
the size of the input array.
Notes
-----
For a small array with few distinct values, one might use
`numpy.unique()` to find all possible values, and ``(arr == val)`` to
locate each value within that array. However, for large arrays,
with many distinct values, this can become extremely inefficient,
as locating each value would require a new search through the entire
array. Using this function, there is essentially one search, with
the indices saved for all distinct values.
This is useful when matching a categorical image (e.g. a segmentation
or classification) to an associated image of other data, allowing
any per-class statistic(s) to then be calculated. Provides a
more flexible alternative to functions like ``scipy.ndimage.mean()``
and ``scipy.ndimage.variance()``.
Some other closely related functionality, with different strengths and
weaknesses, can also be found in ``scipy.stats.binned_statistic()`` and
the `scikit-image <https://scikit-image.org/>`_ function
``skimage.measure.regionprops()``.
Note for IDL users: this provides functionality equivalent to IDL's
REVERSE_INDICES option (as per the IDL documentation for the
`HISTOGRAM <https://www.l3harrisgeospatial.com/docs/histogram.html>`_
function).
.. versionadded:: 1.10.0
See Also
--------
label, maximum, median, minimum_position, extrema, sum, mean, variance,
standard_deviation, numpy.where, numpy.unique
Examples
--------
>>> import numpy as np
>>> from scipy import ndimage
>>> a = np.zeros((6, 6), dtype=int)
>>> a[2:4, 2:4] = 1
>>> a[4, 4] = 1
>>> a[:2, :3] = 2
>>> a[0, 5] = 3
>>> a
array([[2, 2, 2, 0, 0, 3],
[2, 2, 2, 0, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0]])
>>> val_indices = ndimage.value_indices(a)
The dictionary `val_indices` will have an entry for each distinct
value in the input array.
>>> val_indices.keys()
dict_keys([0, 1, 2, 3])
The entry for each value is an index tuple, locating the elements
with that value.
>>> ndx1 = val_indices[1]
>>> ndx1
(array([2, 2, 3, 3, 4]), array([2, 3, 2, 3, 4]))
This can be used to index into the original array, or any other
array with the same shape.
>>> a[ndx1]
array([1, 1, 1, 1, 1])
If the zeros were to be ignored, then the resulting dictionary
would no longer have an entry for zero.
>>> val_indices = ndimage.value_indices(a, ignore_value=0)
>>> val_indices.keys()
dict_keys([1, 2, 3])
)r r Nr )r! �zerosr �typer r )�arrrC �ignore_value_arr� ignoreIsNone� val_indicess r? r r 6 sf � �R �{�4�s�y�9�9�9�� �D�(�L� � H� .� 4� 9� 9�,� G� G�����)�#�|�=M�N�N�K� �rB Fc � ���� t j |� � }t j | � � } |r1t j | j � � � | j � � }��`|�t d� � �|s �| � � � � � S �| � � � |� � � � � S t j | �� � \ } �n"# t $ r} t d� � | �d} ~ ww xY w|�7|s �| �dk � � S �| �dk |�dk � � S t j
|� � }t j |�
�j � � �
|j � � |k � � r t d|j �d�j �d�� � �|�
�j � � }|� � � }
|� � � } �|
k �| k z } �| �| | } |r|| }�� � � }
�|
�| |
} |r||
}|� � � }|| ����fd�}t j |j |� � }||dd�< |s || g|� � n || |g|� � t j |j |� � }|||< |r|d }|S ) a
Roughly equivalent to [func(input[labels == i]) for i in index].
Sequentially applies an arbitrary function (that works on array_like input)
to subsets of an N-D image array specified by `labels` and `index`.
The option exists to provide the function with positional parameters as the
second argument.
Parameters
----------
input : array_like
Data from which to select `labels` to process.
labels : array_like or None
Labels to objects in `input`.
If not None, array must be same shape as `input`.
If None, `func` is applied to raveled `input`.
index : int, sequence of ints or None
Subset of `labels` to which to apply `func`.
If a scalar, a single value is returned.
If None, `func` is applied to all non-zero values of `labels`.
func : callable
Python function to apply to `labels` from `input`.
out_dtype : dtype
Dtype to use for `result`.
default : int, float or None
Default return value when a element of `index` does not exist
in `labels`.
pass_positions : bool, optional
If True, pass linear indices to `func` as a second argument.
Default is False.
Returns
-------
result : ndarray
Result of applying `func` to each of `labels` to `input` in `index`.
Examples
--------
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> lbl, nlbl = ndimage.label(a)
>>> lbls = np.arange(1, nlbl+1)
>>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, 0)
array([ 2.75, 5.5 , 6. ])
Falling back to `default`:
>>> lbls = np.arange(1, nlbl+2)
>>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, -1)
array([ 2.75, 5.5 , 6. , -1. ])
Passing positions:
>>> def fn(val, pos):
... print("fn says: %s : %s" % (val, pos))
... return (val.sum()) if (pos.sum() % 2 == 0) else (-val.sum())
...
>>> ndimage.labeled_comprehension(a, lbl, lbls, fn, float, 0, True)
fn says: [1 2 5 3] : [0 1 4 5]
fn says: [4 7] : [ 7 11]
fn says: [9 3] : [12 13]
array([ 11., 11., -12., 0.])
Nz index without defined labelszMinput and labels must have the same shape (excepting dimensions with width 1)r z"Cannot convert index values from <z> to <z*> (labels' type) without loss of precisionc � ���� �
j }t j � �
d�� � }t j � �
d�� � }t t |� � ||� � D ]"\ }����k r�
���fd�| D � � � ||< �#dS )zlabels must be sorted�left)�side�rightc �$ �� g | ] }|��� ��
S � rQ )�.0�inp�h�ls ��r? �
<listcomp>z9labeled_comprehension.<locals>.do_map.<locals>.<listcomp>1 s! �� � :� :� :�C�s�1�Q�3�x� :� :� :rB N)r+ r! � searchsorted�zip�range) �inputsr7 �nidx�lo�hi�irT rU �func�labels� sorted_indexs @@���r? �do_mapz%labeled_comprehension.<locals>.do_map% s� ���� �� �� �
�� �6�
B�
B�
B��
�
�� �7�
C�
C�
C���5��;�;��B�/�/� <� <�G�A�q�!��A�v�v�� �� :� :� :� :� :�6� :� :� :�;�F�1�I�I� <� <rB )r! �isscalarr" �aranger+ �reshaper) r* �ravel�broadcast_arrays�
atleast_1dr. �any�astyper �minrA �argsortr/ rE )r5 r` �indexr_ � out_dtype�default�pass_positions� as_scalar� positionsr= r\ r] �mask� label_order� index_orderrb �tempr7 ra s ` ` @r? r
r
� s- ���� �L ��u�%�%�I� �M�%� � �E�� B��L���,�,�4�4�U�[�A�A� �
�~� � � � ;�<�<� <� � :��4�� � �
�
�&�&� &��4�� � �
�
�y���'8�'8�9�9� 9�J� �.�u�f�=�=�
��v�v�� � J� J� J�� B� C� C�HI� J�����J����
�}� � B��4��f�q�j�)�*�*� *��4��f�q�j�)�9�V�a�Z�+@�A�A� A� � �U� #� #�E� �v�e�l�l�6�<�(�(�/�/�� �<�<��E�F�F� 9��j� "�[�[�[�&�,�,�,�8� 9� 9� 9�
�L�L�� � &� &�E�
�����B� �����B� �b�L�V�r�\� *�D� �D�\�F� �$�K�E�� $� �d�O� � �.�.�"�"�K�
�K�
�F� �+� �E�� +� �k�*� ��-�-�/�/�K���%�L� <� <� <� <� <� <� <� �;�u�{�I� .� .�D��D����G� � )����w�� � � � ����y�!�4�(�(�(�
�[���i�
0�
0�F� �F�;��� ����� �Ms �C �
C:�%C5�5C:c �� � t j t � � j }t j | t j � � r | j |k p)t j | t j � � o
| j |k }|S )zCTest whether the NumPy data type `dt` can be safely cast to an int.)r. r �int�itemsize�
issubdtype�
signedinteger�unsignedinteger)�dt�int_size�safes r? �_safely_castable_to_intr� B s^ � ��x��}�}�%�H�
�]�2�r� /�
0�
0�
L�R�[�H�5L�
O�
�]�2�r� 1�
2�
2�
M�r�{�X�7M� � �KrB c � � �� � � �fd�}|� |� � � S t j � |� � \ � }|� |� |dk � � S t j |� � r |� ||k � � S � � � fd�}t |j � � r5|� � � dk s |� � � |j k r�t j |d�� � \ }}t j |� � � t j |� �
� � �� � � �r# ||� |j � � � � }t j
||� � } d| | |j k < || |k }
n�t j |�
� � � � � t j |�
� � � �
� � �� � � �r ||� � }t j |t j � � � � � } | dk | � j k z }
d| |
< � | � d� |
< � | � d� |
< �s� � fS || }d||
< � � |fS )a� Count, sum, and optionally compute (sum - centre)^2 of input by label
Parameters
----------
input : array_like, N-D
The input data to be analyzed.
labels : array_like (N-D), optional
The labels of the data in `input`. This array must be broadcast
compatible with `input`; typically, it is the same shape as `input`.
If `labels` is None, all nonzero values in `input` are treated as
the single labeled group.
index : label or sequence of labels, optional
These are the labels of the groups for which the stats are computed.
If `index` is None, the stats are computed for the single group where
`labels` is greater than 0.
centered : bool, optional
If True, the centered sum of squares for each labeled group is
also returned. Default is False.
Returns
-------
counts : int or ndarray of ints
The number of elements in each labeled group.
sums : scalar or ndarray of scalars
The sums of the values in each labeled group.
sums_c : scalar or ndarray of scalars, optional
The sums of mean-centered squares of the values in each labeled group.
This is only returned if `centered` is True.
c �� �� �rZ| | � � � z
}| j | � � � ||� � � z � � � fS | j | � � � fS )N)r r+ r � conjugate)�vals�vals_c�centereds �r? � single_groupz _stats.<locals>.single_groupi sf �� � � )��D�I�I�K�K�'�F��9�d�h�h�j�j�6�F�4D�4D�4F�4F�+F�*K�*K�*M�*M�M� M��9�d�h�h�j�j�(� (rB Nr c �� �� ��z }�|| z
}t j | � � � ||� � � z � � � �� � }|S )N��weights)r! �bincountrf r� )r` �means�centered_input�bc�countsr5 �sumss ���r? �
_sum_centeredz _stats.<locals>._sum_centered| sg �� � �v�
�� ��v� �.��
�^�F�L�L�N�N�'5�'5�'?�'?�'A�'A�(B�CH�5�7�7�L� L� L�� � rB T��return_inverser� )r! rg rc r� r rk rA r+ �uniquer� rf re r) rW �
asanyarray�int_�copy)
r5 r` rm r� r� r� �
unique_labels�
new_labels�sums_c�idxs�foundr� r� s
` ` @@r? �_statsr� J s� ����� �>)� )� )� )� )� �~��|�E�"�"�"� �*�5�&�9�9�M�E�6� �}��|�E�&�1�*� -�.�.�.� �~�e� � � 4��|�E�&�E�/� 2�3�3�3�
�
�
�
�
�
�
�
$�F�L� 1� 1� � �J�J�L�L�1� � ��
�
� � �v�{� :� :� %*�L���$M�$M�$M�!�
�z�� �
�+�+���~�j�%�+�+�-�-�@�@�@�� � E� #�]�:�#5�#5�f�l�#C�#C�D�D�F��!�-��7�7��+,��T�]�'�
'�(� �t�$��-��� � �� � ���/�/���~�f�l�l�n�n�e�k�k�m�m�D�D�D�� � +�"�]�6�*�*�F�� ��u�z�2�2�7�7�9�9�����t�f�k� 1�2����e�V� �
�D�\�F��F�E�6�N� ��:�D��D�%��L� � &���~� ��� �����v����f�%�%rB c �$ � t | ||� � S )a
Calculate the sum of the values of the array.
Notes
-----
This is an alias for `ndimage.sum_labels` kept for backwards compatibility
reasons, for new code please prefer `sum_labels`. See the `sum_labels`
docstring for more details.
)r �r5 r` rm s r? r r � s � � �e�V�U� +� +�+rB c �. � t | ||� � \ }}|S )a
Calculate the sum of the values of the array.
Parameters
----------
input : array_like
Values of `input` inside the regions defined by `labels`
are summed together.
labels : array_like of ints, optional
Assign labels to the values of the array. Has to have the same shape as
`input`.
index : array_like, optional
A single label number or a sequence of label numbers of
the objects to be measured.
Returns
-------
sum : ndarray or scalar
An array of the sums of values of `input` inside the regions defined
by `labels` with the same shape as `index`. If 'index' is None or scalar,
a scalar is returned.
See Also
--------
mean, median
Examples
--------
>>> from scipy import ndimage
>>> input = [0,1,2,3]
>>> labels = [1,1,2,2]
>>> ndimage.sum_labels(input, labels, index=[1,2])
[1.0, 5.0]
>>> ndimage.sum_labels(input, labels, index=1)
1
>>> ndimage.sum_labels(input, labels)
6
)r� �r5 r` rm �countr s r? r r � s � �R ��v�u�-�-�J�E�3� �JrB c � � t | ||� � \ }}|t j |� � � t j � � z S )a�
Calculate the mean of the values of an array at labels.
Parameters
----------
input : array_like
Array on which to compute the mean of elements over distinct
regions.
labels : array_like, optional
Array of labels of same shape, or broadcastable to the same shape as
`input`. All elements sharing the same label form one region over
which the mean of the elements is computed.
index : int or sequence of ints, optional
Labels of the objects over which the mean is to be computed.
Default is None, in which case the mean for all values where label is
greater than 0 is calculated.
Returns
-------
out : list
Sequence of same length as `index`, with the mean of the different
regions labeled by the labels in `index`.
See Also
--------
variance, standard_deviation, minimum, maximum, sum, label
Examples
--------
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.arange(25).reshape((5,5))
>>> labels = np.zeros_like(a)
>>> labels[3:5,3:5] = 1
>>> index = np.unique(labels)
>>> labels
array([[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 1, 1],
[0, 0, 0, 1, 1]])
>>> index
array([0, 1])
>>> ndimage.mean(a, labels=labels, index=index)
[10.285714285714286, 21.0]
)r� r! r� rj �float64r� s r? r r � s@ � �b ��v�u�-�-�J�E�3� ��!�%�(�(�/�/��
�>�>� >�>rB c � � t | ||d�� � \ }}}|t j |� � � t � � z S )a)
Calculate the variance of the values of an N-D image array, optionally at
specified sub-regions.
Parameters
----------
input : array_like
Nd-image data to process.
labels : array_like, optional
Labels defining sub-regions in `input`.
If not None, must be same shape as `input`.
index : int or sequence of ints, optional
`labels` to include in output. If None (default), all values where
`labels` is non-zero are used.
Returns
-------
variance : float or ndarray
Values of variance, for each sub-region if `labels` and `index` are
specified.
See Also
--------
label, standard_deviation, maximum, minimum, extrema
Examples
--------
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> ndimage.variance(a)
7.609375
Features to process can be specified using `labels` and `index`:
>>> lbl, nlbl = ndimage.label(a)
>>> ndimage.variance(a, lbl, index=np.arange(1, nlbl+1))
array([ 2.1875, 2.25 , 9. ])
If no index is given, all non-zero `labels` are processed:
>>> ndimage.variance(a, lbl)
6.1875
T)r� )r� r. r� rj �float)r5 r` rm r� r �sum_c_sqs r? r
r
% sE � �b "�%����F�F�F��E�3�� �b�m�E�*�*�1�1�%�8�8� 8�8rB c �H � t j t | ||� � � � S )am
Calculate the standard deviation of the values of an N-D image array,
optionally at specified sub-regions.
Parameters
----------
input : array_like
N-D image data to process.
labels : array_like, optional
Labels to identify sub-regions in `input`.
If not None, must be same shape as `input`.
index : int or sequence of ints, optional
`labels` to include in output. If None (default), all values where
`labels` is non-zero are used.
Returns
-------
standard_deviation : float or ndarray
Values of standard deviation, for each sub-region if `labels` and
`index` are specified.
See Also
--------
label, variance, maximum, minimum, extrema
Examples
--------
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> ndimage.standard_deviation(a)
2.7585095613392387
Features to process can be specified using `labels` and `index`:
>>> lbl, nlbl = ndimage.label(a)
>>> ndimage.standard_deviation(a, lbl, index=np.arange(1, nlbl+1))
array([ 1.479, 1.5 , 3. ])
If no index is given, non-zero `labels` are processed:
>>> ndimage.standard_deviation(a, lbl)
2.4874685927665499
)r! �sqrtr
r� s r? r r Z s! � �b �:�h�u�f�e�4�4� 5� 5�5rB c �R
������ t j | � � } �p�}d} |r1t j | j � � � | j � � } �����fd�}
|� |
| | � � S t j | |� � \ } }|�$|dk } d} |r| | } |
| | | � � S t j |� � r$||k } d} |r| | } |
| | | � � S t |j � � r5|�
� � dk s |� � � |j k rIt j |d�� � \ }
}t j
|
|� � }d|||
j k < |
| |k }nPt j |t j � � � � � }|dk ||� � � k z }|� � � dz || < �r;t j | � � � |� � � f� � }n&| � � � � � � }| � � � | } |� � � | }|r| � � � | } g }�rRt j |� � � dz | j � � }| ddd� ||ddd� < ||| gz
}�rRt j |� � � dz t( � � }| ddd� ||ddd� < ||| gz
}�r@t j |� � � dz | j � � }| ||< ||| gz
}�r@t j |� � � dz t( � � }| ||< ||| gz
}��rft j t+ |� � � � }t j |� � � dz t j � � }|ddd� ||ddd� < t j |� � � dz t j � � }|||< || }|| }||z
dz }||z
}||z }t- j | j t, j � � s$t- j | j t, j � � r?|| | � d � � | | � d � � z d
z gz
}n|| | | | z d
z gz
}|S ) zOReturns min, max, or both, plus their positions (if requested), and
median.Nc �P �� g }�r|| � � � gz
}�r(||| | � � � k d gz
}�r|| � � � gz
}�r(||| | � � � k d gz
}�r|t j | � � gz
}|S �Nr )rk rA r! r )r� rr �result�find_max�find_max_positions� find_median�find_min�find_min_positionss �����r? r� z _select.<locals>.single_group� s� �� ��� � #� �t�x�x�z�z�l� "�F� � 9� �y�������!3�4�Q�7�8� 8�F� � #� �t�x�x�z�z�l� "�F� � 9� �y�������!3�4�Q�7�8� 8�F� � +� �u�|�D�)�)�*� *�F��
rB r Tr� r � ����dg @)r! r� rd r+ re r) rg rc r� r rk rA r� rW r� r� �lexsortrf rl rE rx �lenr. rz �integer�bool_rj )r5 r` rm r� r� r� r� r� �find_positionsrr r� rs �masked_positionsr� r� r� �orderr� �mins�minpos�maxs�maxpos�locsr\ r] �steps ````` r? �_selectr� � s ������ �
� �U� #� #�E�'�=�+=�N��I�� B��L���,�,�4�4�U�[�A�A� � � � � � � � � � � �~��|�E�9�-�-�-� �*�5�&�9�9�M�E�6� �}���
�� �� � /� (��� ��|�E�$�K�)9�:�:�:� �~�e� � � ;��%��� �� � /� (��� ��|�E�$�K�)9�:�:�:�
$�F�L� 1� 1� 5� �J�J�L�L�1� � ��
�
� � �v�{� :� :� %� �V�D� I� I� I� �
�v��!�-��7�7�� ,-��T�]�'�
'�(� �t�$��-��� � ��u�z�2�2�7�7�9�9�����t�v�z�z�|�|� 3�4���J�J�L�L�1�$�D�5��M�� (��
�u�{�{�}�}�f�l�l�n�n� =�>�>���� � �
�
�%�%�'�'�� �K�K�M�M�%� �E�
�\�\�^�^�E�
"�F�� -� �O�O�%�%�e�,� �
�F�� ��{�6�:�:�<�<�!�+�U�[�9�9�� "�4�4�R�4�[��V�D�D�b�D�\���4��:�,� ��� !���V�Z�Z�\�\�A� -�s�3�3�� (���2����v�d�d��d�|� ��6�$�<�.� ��� ��{�6�:�:�<�<�!�+�U�[�9�9�� ��V� ��4��:�,� ��� !���V�Z�Z�\�\�A� -�s�3�3��"��v���6�$�<�.� ��� 6��|�C��K�K�(�(��
�[���� � ��)�5�:�
6�
6�� ���"��:��6�$�$�B�$�<��
�[���� � ��)�5�:�
6�
6����6�
�
��X��
��X��
�R��A�~��
�d�
��
�d�
�� �M�%�+�r�z� 2� 2� 6��=���b�h�7�7� 6�
��b� �(�(��-�-��b� �0@�0@��0E�0E�E��L�M� M�F�F� ��b� �E�"�I�-��4�5� 5�F� �MrB c �4 � t | ||d�� � d S )a�
Calculate the minimum of the values of an array over labeled regions.
Parameters
----------
input : array_like
Array_like of values. For each region specified by `labels`, the
minimal values of `input` over the region is computed.
labels : array_like, optional
An array_like of integers marking different regions over which the
minimum value of `input` is to be computed. `labels` must have the
same shape as `input`. If `labels` is not specified, the minimum
over the whole array is returned.
index : array_like, optional
A list of region labels that are taken into account for computing the
minima. If index is None, the minimum over all elements where `labels`
is non-zero is returned.
Returns
-------
minimum : float or list of floats
List of minima of `input` over the regions determined by `labels` and
whose index is in `index`. If `index` or `labels` are not specified, a
float is returned: the minimal value of `input` if `labels` is None,
and the minimal value of elements where `labels` is greater than zero
if `index` is None.
See Also
--------
label, maximum, median, minimum_position, extrema, sum, mean, variance,
standard_deviation
Notes
-----
The function returns a Python list and not a NumPy array, use
`np.array` to convert the list to an array.
Examples
--------
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> labels, labels_nb = ndimage.label(a)
>>> labels
array([[1, 1, 0, 0],
[1, 1, 0, 2],
[0, 0, 0, 2],
[3, 3, 0, 0]])
>>> ndimage.minimum(a, labels=labels, index=np.arange(1, labels_nb + 1))
[1.0, 4.0, 3.0]
>>> ndimage.minimum(a)
0.0
>>> ndimage.minimum(a, labels=labels)
1.0
T)r� r �r� r� s r? r r s! � �x �5�&�%�$� 7� 7� 7�� :�:rB c �4 � t | ||d�� � d S )a�
Calculate the maximum of the values of an array over labeled regions.
Parameters
----------
input : array_like
Array_like of values. For each region specified by `labels`, the
maximal values of `input` over the region is computed.
labels : array_like, optional
An array of integers marking different regions over which the
maximum value of `input` is to be computed. `labels` must have the
same shape as `input`. If `labels` is not specified, the maximum
over the whole array is returned.
index : array_like, optional
A list of region labels that are taken into account for computing the
maxima. If index is None, the maximum over all elements where `labels`
is non-zero is returned.
Returns
-------
output : float or list of floats
List of maxima of `input` over the regions determined by `labels` and
whose index is in `index`. If `index` or `labels` are not specified, a
float is returned: the maximal value of `input` if `labels` is None,
and the maximal value of elements where `labels` is greater than zero
if `index` is None.
See Also
--------
label, minimum, median, maximum_position, extrema, sum, mean, variance,
standard_deviation
Notes
-----
The function returns a Python list and not a NumPy array, use
`np.array` to convert the list to an array.
Examples
--------
>>> import numpy as np
>>> a = np.arange(16).reshape((4,4))
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> labels = np.zeros_like(a)
>>> labels[:2,:2] = 1
>>> labels[2:, 1:3] = 2
>>> labels
array([[1, 1, 0, 0],
[1, 1, 0, 0],
[0, 2, 2, 0],
[0, 2, 2, 0]])
>>> from scipy import ndimage
>>> ndimage.maximum(a)
15.0
>>> ndimage.maximum(a, labels=labels, index=[1,2])
[5.0, 14.0]
>>> ndimage.maximum(a, labels=labels)
14.0
>>> b = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> labels, labels_nb = ndimage.label(b)
>>> labels
array([[1, 1, 0, 0],
[1, 1, 0, 2],
[0, 0, 0, 2],
[3, 3, 0, 0]])
>>> ndimage.maximum(b, labels=labels, index=np.arange(1, labels_nb + 1))
[5.0, 7.0, 9.0]
T)r� r r� r� s r? r r A s! � �Z �5�&�%�$� 7� 7� 7�� :�:rB c �4 � t | ||d�� � d S )a�
Calculate the median of the values of an array over labeled regions.
Parameters
----------
input : array_like
Array_like of values. For each region specified by `labels`, the
median value of `input` over the region is computed.
labels : array_like, optional
An array_like of integers marking different regions over which the
median value of `input` is to be computed. `labels` must have the
same shape as `input`. If `labels` is not specified, the median
over the whole array is returned.
index : array_like, optional
A list of region labels that are taken into account for computing the
medians. If index is None, the median over all elements where `labels`
is non-zero is returned.
Returns
-------
median : float or list of floats
List of medians of `input` over the regions determined by `labels` and
whose index is in `index`. If `index` or `labels` are not specified, a
float is returned: the median value of `input` if `labels` is None,
and the median value of elements where `labels` is greater than zero
if `index` is None.
See Also
--------
label, minimum, maximum, extrema, sum, mean, variance, standard_deviation
Notes
-----
The function returns a Python list and not a NumPy array, use
`np.array` to convert the list to an array.
Examples
--------
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 1],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> labels, labels_nb = ndimage.label(a)
>>> labels
array([[1, 1, 0, 2],
[1, 1, 0, 2],
[0, 0, 0, 2],
[3, 3, 0, 0]])
>>> ndimage.median(a, labels=labels, index=np.arange(1, labels_nb + 1))
[2.5, 4.0, 6.0]
>>> ndimage.median(a)
1.0
>>> ndimage.median(a, labels=labels)
3.0
T)r� r r� r� s r? r r � s! � �v �5�&�%�T� :� :� :�1� =�=rB c � � t j t j | � � j � � }t j dgt |ddd� � � z � � ddd� }t
| ||d�� � d }t j |� � rt ||z |z � � S d� |� dd� � |z |z D � � S )a�
Find the positions of the minimums of the values of an array at labels.
Parameters
----------
input : array_like
Array_like of values.
labels : array_like, optional
An array of integers marking different regions over which the
position of the minimum value of `input` is to be computed.
`labels` must have the same shape as `input`. If `labels` is not
specified, the location of the first minimum over the whole
array is returned.
The `labels` argument only works when `index` is specified.
index : array_like, optional
A list of region labels that are taken into account for finding the
location of the minima. If `index` is None, the ``first`` minimum
over all elements where `labels` is non-zero is returned.
The `index` argument only works when `labels` is specified.
Returns
-------
output : list of tuples of ints
Tuple of ints or list of tuples of ints that specify the location
of minima of `input` over the regions determined by `labels` and
whose index is in `index`.
If `index` or `labels` are not specified, a tuple of ints is
returned specifying the location of the first minimal value of `input`.
See Also
--------
label, minimum, median, maximum_position, extrema, sum, mean, variance,
standard_deviation
Examples
--------
>>> import numpy as np
>>> a = np.array([[10, 20, 30],
... [40, 80, 100],
... [1, 100, 200]])
>>> b = np.array([[1, 2, 0, 1],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> ndimage.minimum_position(a)
(2, 0)
>>> ndimage.minimum_position(b)
(0, 2)
Features to process can be specified using `labels` and `index`:
>>> label, pos = ndimage.label(a)
>>> ndimage.minimum_position(a, label, index=np.arange(1, pos+1))
[(2, 0)]
>>> label, pos = ndimage.label(b)
>>> ndimage.minimum_position(b, label, index=np.arange(1, pos+1))
[(0, 0), (0, 3), (3, 1)]
r Nr r� T)r� c �, � g | ]}t |� � ��S rQ ��tuple�rR �vs r? rV z$minimum_position.<locals>.<listcomp> � � � I� I� I��E�!�H�H� I� I� IrB �
r! �arrayr" r) �cumprod�listr� rc r� re �r5 r` rm �dims�dim_prodr� s r? r r � s� � �F �;�u�}�U�+�+�1� 2� 2�D��}�a�S�4��U�a��U� �#4�#4� 4�5�5�d�d��d�;�H�
�U�F�E�d�
C�
C�
C�A�
F�F� �~�f� � � 2��f��(�D�0�1�1�1� I� I�v�~�~�b�!� 4� 4�� @�D� H� I� I� I�IrB c � � t j t j | � � j � � }t j dgt |ddd� � � z � � ddd� }t
| ||d�� � d }t j |� � rt ||z |z � � S d� |� dd� � |z |z D � � S )a
Find the positions of the maximums of the values of an array at labels.
For each region specified by `labels`, the position of the maximum
value of `input` within the region is returned.
Parameters
----------
input : array_like
Array_like of values.
labels : array_like, optional
An array of integers marking different regions over which the
position of the maximum value of `input` is to be computed.
`labels` must have the same shape as `input`. If `labels` is not
specified, the location of the first maximum over the whole
array is returned.
The `labels` argument only works when `index` is specified.
index : array_like, optional
A list of region labels that are taken into account for finding the
location of the maxima. If `index` is None, the first maximum
over all elements where `labels` is non-zero is returned.
The `index` argument only works when `labels` is specified.
Returns
-------
output : list of tuples of ints
List of tuples of ints that specify the location of maxima of
`input` over the regions determined by `labels` and whose index
is in `index`.
If `index` or `labels` are not specified, a tuple of ints is
returned specifying the location of the ``first`` maximal value
of `input`.
See also
--------
label, minimum, median, maximum_position, extrema, sum, mean, variance,
standard_deviation
Examples
--------
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> ndimage.maximum_position(a)
(3, 0)
Features to process can be specified using `labels` and `index`:
>>> lbl = np.array([[0, 1, 2, 3],
... [0, 1, 2, 3],
... [0, 1, 2, 3],
... [0, 1, 2, 3]])
>>> ndimage.maximum_position(a, lbl, 1)
(1, 1)
If no index is given, non-zero `labels` are processed:
>>> ndimage.maximum_position(a, lbl)
(2, 3)
If there are no maxima, the position of the first element is returned:
>>> ndimage.maximum_position(a, lbl, 2)
(0, 2)
r Nr r� T)r� c �, � g | ]}t |� � ��S rQ r� r� s r? rV z$maximum_position.<locals>.<listcomp>p r� rB r� r� s r? r r s� � �R �;�u�}�U�+�+�1� 2� 2�D��}�a�S�4��U�a��U� �#4�#4� 4�5�5�d�d��d�;�H�
�U�F�E�d�
C�
C�
C�A�
F�F� �~�f� � � 2��f��(�D�0�1�1�1� I� I�v�~�~�b�!� 4� 4�� @�D� H� I� I� I�IrB c � � t j t j | � � j � � }t j dgt |ddd� � � z � � ddd� }t
| ||dddd�� � \ }}}}t j |� � r,||t ||z |z � � t ||z |z � � fS d� |� dd� � |z |z D � � }d� |� dd� � |z |z D � � }||||fS ) a�
Calculate the minimums and maximums of the values of an array
at labels, along with their positions.
Parameters
----------
input : ndarray
N-D image data to process.
labels : ndarray, optional
Labels of features in input.
If not None, must be same shape as `input`.
index : int or sequence of ints, optional
Labels to include in output. If None (default), all values where
non-zero `labels` are used.
Returns
-------
minimums, maximums : int or ndarray
Values of minimums and maximums in each feature.
min_positions, max_positions : tuple or list of tuples
Each tuple gives the N-D coordinates of the corresponding minimum
or maximum.
See Also
--------
maximum, minimum, maximum_position, minimum_position, center_of_mass
Examples
--------
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> ndimage.extrema(a)
(0, 9, (0, 2), (3, 0))
Features to process can be specified using `labels` and `index`:
>>> lbl, nlbl = ndimage.label(a)
>>> ndimage.extrema(a, lbl, index=np.arange(1, nlbl+1))
(array([1, 4, 3]),
array([5, 7, 9]),
[(0, 0), (1, 3), (3, 1)],
[(1, 0), (2, 3), (3, 0)])
If no index is given, non-zero `labels` are processed:
>>> ndimage.extrema(a, lbl)
(1, 9, (0, 0), (3, 0))
r Nr r� T)r� r� r� r� c �, � g | ]}t |� � ��S rQ r� r� s r? rV zextrema.<locals>.<listcomp>� � � �Y�Y�Y�!�U�1�X�X�Y�Y�YrB c �, � g | ]}t |� � ��S rQ r� r� s r? rV zextrema.<locals>.<listcomp>� r� rB r� ) r5 r` rm r� r� �minimums�
min_positions�maximums�
max_positionss r? r r s sA � �l �;�u�}�U�+�+�1� 2� 2�D��}�a�S�4��U�a��U� �#4�#4� 4�5�5�d�d��d�;�H�7>�u�f�?D�HL�HL�RV�RV� 8X� 8X� 8X�4�H�m�X�}�
�~�h� � � ;��(�E�=�H�+D��*L�$M�$M��}��0�D�8�9�9�;� ;� Z�Y�
�(=�(=�b�!�(D�(D��(P�TX�'X�Y�Y�Y�M�Y�Y�
�(=�(=�b�!�(D�(D��(P�TX�'X�Y�Y�Y�M� �X�}�m� ;�;rB c �P � ����� t � ��� � �t j d� � j D � � ���� ��fd�t � j � � D � � }t j |d � � rt |� � S d� t j |� � j D � � S )a�
Calculate the center of mass of the values of an array at labels.
Parameters
----------
input : ndarray
Data from which to calculate center-of-mass. The masses can either
be positive or negative.
labels : ndarray, optional
Labels for objects in `input`, as generated by `ndimage.label`.
Only used with `index`. Dimensions must be the same as `input`.
index : int or sequence of ints, optional
Labels for which to calculate centers-of-mass. If not specified,
the combined center of mass of all labels greater than zero
will be calculated. Only used with `labels`.
Returns
-------
center_of_mass : tuple, or list of tuples
Coordinates of centers-of-mass.
Examples
--------
>>> import numpy as np
>>> a = np.array(([0,0,0,0],
... [0,1,1,0],
... [0,1,1,0],
... [0,1,1,0]))
>>> from scipy import ndimage
>>> ndimage.center_of_mass(a)
(2.0, 1.5)
Calculation of multiple objects in an image
>>> b = np.array(([0,1,1,0],
... [0,1,0,0],
... [0,0,0,0],
... [0,0,1,1],
... [0,0,1,1]))
>>> lbl = ndimage.label(b)[0]
>>> ndimage.center_of_mass(b, lbl, [1,2])
[(0.33333333333333331, 1.3333333333333333), (3.5, 2.5)]
Negative masses are also accepted, which can occur for example when
bias is removed from measured data due to random noise.
>>> c = np.array(([-1,0,0,0],
... [0,-1,-1,0],
... [0,1,-1,0],
... [0,1,1,0]))
>>> ndimage.center_of_mass(c)
(-4.0, 1.0)
If there are division by zero issues, the function does not raise an
error but rather issues a RuntimeWarning before returning inf and/or NaN.
>>> d = np.array([-1, 1])
>>> ndimage.center_of_mass(d)
(inf,)
c �. � g | ]}t d |� � ��S �r )�slice)rR r^ s r? rV z"center_of_mass.<locals>.<listcomp>� s � �:�:�:���q�!���:�:�:rB c �z �� g | ]7}t ��| � t � � z ��� � �z ��8S rQ )r rj r� )rR �dir�gridsrm r5 r` �
normalizers �����r? rV z"center_of_mass.<locals>.<listcomp>� sQ �� � -� -� -�� �5�5��:�,�,�U�3�3�3�V�U�C�C�j�P� -� -� -rB r c �, � g | ]}t |� � ��S rQ r� r� s r? rV z"center_of_mass.<locals>.<listcomp> s � � 5� 5� 5��E�!�H�H� 5� 5� 5rB )
r r! �ogridr) rY r& rc r� r� �T)r5 r` rm �resultsr� r� s ``` @@r? r r � s� ������ �z �U�F�E�*�*�J� �K�:�:�e�k�:�:�:� ;�E�-� -� -� -� -� -� -� -� ��
�+�+�-� -� -�G�
�~�g�a�j�!�!� ��W�~�~� � 5� 5�e�k�'� 2� 2� 4� 5� 5� 5�5rB c �v �� t j |||dz � � ��fd�}t | |||t dd�� � S )a�
Calculate the histogram of the values of an array, optionally at labels.
Histogram calculates the frequency of values in an array within bins
determined by `min`, `max`, and `bins`. The `labels` and `index`
keywords can limit the scope of the histogram to specified sub-regions
within the array.
Parameters
----------
input : array_like
Data for which to calculate histogram.
min, max : int
Minimum and maximum values of range of histogram bins.
bins : int
Number of bins.
labels : array_like, optional
Labels for objects in `input`.
If not None, must be same shape as `input`.
index : int or sequence of ints, optional
Label or labels for which to calculate histogram. If None, all values
where label is greater than zero are used
Returns
-------
hist : ndarray
Histogram counts.
Examples
--------
>>> import numpy as np
>>> a = np.array([[ 0. , 0.2146, 0.5962, 0. ],
... [ 0. , 0.7778, 0. , 0. ],
... [ 0. , 0. , 0. , 0. ],
... [ 0. , 0. , 0.7181, 0.2787],
... [ 0. , 0. , 0.6573, 0.3094]])
>>> from scipy import ndimage
>>> ndimage.histogram(a, 0, 1, 10)
array([13, 0, 2, 1, 0, 1, 1, 2, 0, 0])
With labels and no indices, non-zero elements are counted:
>>> lbl, nlbl = ndimage.label(a)
>>> ndimage.histogram(a, 0, 1, 10, lbl)
array([0, 0, 2, 1, 0, 1, 1, 2, 0, 0])
Indices can be used to count only certain objects:
>>> ndimage.histogram(a, 0, 1, 10, lbl, 2)
array([0, 0, 1, 1, 0, 0, 1, 1, 0, 0])
r c �: �� t j | �� � d S r� )r! r )r� �_binss �r? �_histzhistogram.<locals>._hist> s �� ���t�U�+�+�A�.�.rB NF)rp )r! �linspacer
�object)r5 rk rA �binsr` rm r� r� s @r? r r s^ �� �j
�N�3��T�A�X� .� .�E�/� /� /� /� /� !����u�f�d�05� 7� 7� 7� 7rB c �� � t j | � � } | j j t j t j fvrt
d� � �|�t j | j d� � }t j |t �� � }|j | j k rt d� � �|j D ]}|dk rt d� � ��|j
j s|� � � }t j |� � }| j |j k rt d� � �t j t j t j t j t j t j t j g}|j j |vrt d � � �t/ |t j � � r |j j |vrt d
� � �n|j }t3 j || � � }t7 j | |||� � |S ) a
Apply watershed from markers using image foresting transform algorithm.
Parameters
----------
input : array_like
Input.
markers : array_like
Markers are points within each watershed that form the beginning
of the process. Negative markers are considered background markers
which are processed after the other markers.
structure : structure element, optional
A structuring element defining the connectivity of the object can be
provided. If None, an element is generated with a squared
connectivity equal to one.
output : ndarray, optional
An output array can optionally be provided. The same shape as input.
Returns
-------
watershed_ift : ndarray
Output. Same shape as `input`.
References
----------
.. [1] A.X. Falcao, J. Stolfi and R. de Alencar Lotufo, "The image
foresting transform: theory, algorithms, and applications",
Pattern Analysis and Machine Intelligence, vol. 26, pp. 19-29, 2004.
z+only 8 and 16 unsigned inputs are supportedNr r r r r z'input and markers must have equal shapez marker should be of integer typez output should be of integer type) r! r" r rF �uint8�uint16r$ r r% r& r' r( r) �flags�
contiguousr� �int8�int16r1 r� �int64�intcr0 r, r- r � _get_outputr r )r5 �markersr6 r7 r8 �integral_typess r? r r E s� � �>
�M�%� � �E� �{��� �U�\� :�:�:��E�F�F�F��� �9�%�*�a�H�H� ��
�i�t�4�4�4�I��~���#�#��E�F�F�F��o� J� J��
��7�7� � H�I�I� I� � �?� %� %� �N�N�$�$� ��m�G�$�$�G� �{�g�m�#�#��D�E�E�E��j��k��k��j��k��j��j�
"�N� �}�� �/�/��=�>�>�>��&�%�-�(�(� � �<� �N� 2� 2� � A�B�B� B� 3� � ��
�
$�V�U�
3�
3�F�
��E�7�I�v�>�>�>� �MrB )NNr� )F)NNF)NNFFFFF) r! r. � r r r r �__all__r r r r
r� r� r r r r
r r� r r r r r r r r r rQ rB r? �<module>r s� ��>
� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � H� H� H�� A!� A!� A!� A!�HC4� C4� C4� C4�L (,� o� o� o� o� o�dW� W� W� W�t� � �h&� h&� h&� h&�V ,� ,� ,� ,� *� *� *� *�Z2?� 2?� 2?� 2?�j29� 29� 29� 29�j16� 16� 16� 16�h FK�9>� �q� q� q� q�h<;� <;� <;� <;�~M;� M;� M;� M;�`;>� ;>� ;>� ;>�|LJ� LJ� LJ� LJ�^RJ� RJ� RJ� RJ�jH<� H<� H<� H<�VF6� F6� F6� F6�R;7� ;7� ;7� ;7�|E� E� E� E� E� ErB