
    1-Ph                     8    d dl Z d dlZd dlmZ ddgZd ZddZdS )	    N)
as_stridedview_as_blocksview_as_windowsc                 .   t          |t                    st          d          t          j        |          }|dk                                    rt          d          |j        | j        k    rt          d          t          j        | j	                  }||z  
                                dk    rt          d          t          ||z            t          |          z   }t          | j        |z            | j        z   }t          | ||          }|S )aB  Block view of the input n-dimensional array (using re-striding).

    Blocks are non-overlapping views of the input array.

    Parameters
    ----------
    arr_in : ndarray, shape (M[, ...])
        Input array.
    block_shape : tuple
        The shape of the block. Each dimension must divide evenly into the
        corresponding dimensions of `arr_in`.

    Returns
    -------
    arr_out : ndarray
        Block view of the input array.

    Examples
    --------
    >>> import numpy as np
    >>> from skimage.util.shape import view_as_blocks
    >>> A = np.arange(4*4).reshape(4,4)
    >>> A
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    >>> B = view_as_blocks(A, block_shape=(2, 2))
    >>> B[0, 0]
    array([[0, 1],
           [4, 5]])
    >>> B[0, 1]
    array([[2, 3],
           [6, 7]])
    >>> B[1, 0, 1, 1]
    13

    >>> A = np.arange(4*4*6).reshape(4,4,6)
    >>> A  # doctest: +NORMALIZE_WHITESPACE
    array([[[ 0,  1,  2,  3,  4,  5],
            [ 6,  7,  8,  9, 10, 11],
            [12, 13, 14, 15, 16, 17],
            [18, 19, 20, 21, 22, 23]],
           [[24, 25, 26, 27, 28, 29],
            [30, 31, 32, 33, 34, 35],
            [36, 37, 38, 39, 40, 41],
            [42, 43, 44, 45, 46, 47]],
           [[48, 49, 50, 51, 52, 53],
            [54, 55, 56, 57, 58, 59],
            [60, 61, 62, 63, 64, 65],
            [66, 67, 68, 69, 70, 71]],
           [[72, 73, 74, 75, 76, 77],
            [78, 79, 80, 81, 82, 83],
            [84, 85, 86, 87, 88, 89],
            [90, 91, 92, 93, 94, 95]]])
    >>> B = view_as_blocks(A, block_shape=(1, 2, 2))
    >>> B.shape
    (4, 2, 3, 1, 2, 2)
    >>> B[2:, 0, 2]  # doctest: +NORMALIZE_WHITESPACE
    array([[[[52, 53],
             [58, 59]]],
           [[[76, 77],
             [82, 83]]]])
    zblock needs to be a tupler   z0'block_shape' elements must be strictly positivez9'block_shape' must have the same length as 'arr_in.shape'z-'block_shape' is not compatible with 'arr_in'shapestrides)
isinstancetuple	TypeErrornparrayany
ValueErrorsizendimr   sumr	   r   )arr_inblock_shape	arr_shape	new_shapenew_stridesarr_outs         R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/skimage/util/shape.pyr   r      s   B k5)) 53444(;''Kq MKLLL6;&&WXXX&&IK$$&&!++HIII i;.//%2D2DDI455FKy+FFFGN       c                    t          | t          j                  st          d          | j        }t          |t
          j                  r|f|z  }t          |          |k    st          d          t          |t
          j                  r|dk     rt          d          |f|z  }t          |          |k    rt          d          t          j	        | j
                  }t          j	        ||j                  }||z
  dk                                     rt          d          |dz
  dk                                     rt          d	          t          d
 |D                       }t          j	        | j                  }| |         j        }t          j	        | j
                  t          j	        |          z
  t          j	        |          z  dz   }t          t          |          t          |          z             }	t          t          |          t          |          z             }
t!          | |	|
          }|S )a~  Rolling window view of the input n-dimensional array.

    Windows are overlapping views of the input array, with adjacent windows
    shifted by a single row or column (or an index of a higher dimension).

    Parameters
    ----------
    arr_in : ndarray, shape (M[, ...])
        Input array.
    window_shape : integer or tuple of length arr_in.ndim
        Defines the shape of the elementary n-dimensional orthotope
        (better know as hyperrectangle [1]_) of the rolling window view.
        If an integer is given, the shape will be a hypercube of
        sidelength given by its value.
    step : integer or tuple of length arr_in.ndim
        Indicates step size at which extraction shall be performed.
        If integer is given, then the step is uniform in all dimensions.

    Returns
    -------
    arr_out : ndarray
        (rolling) window view of the input array.

    Notes
    -----
    One should be very careful with rolling views when it comes to
    memory usage.  Indeed, although a 'view' has the same memory
    footprint as its base array, the actual array that emerges when this
    'view' is used in a computation is generally a (much) larger array
    than the original, especially for 2-dimensional arrays and above.

    For example, let us consider a 3 dimensional array of size (100,
    100, 100) of ``float64``. This array takes about 8*100**3 Bytes for
    storage which is just 8 MB. If one decides to build a rolling view
    on this array with a window of (3, 3, 3) the hypothetical size of
    the rolling view (if one was to reshape the view for example) would
    be 8*(100-3+1)**3*3**3 which is about 203 MB! The scaling becomes
    even worse as the dimension of the input array becomes larger.

    References
    ----------
    .. [1] https://en.wikipedia.org/wiki/Hyperrectangle

    Examples
    --------
    >>> import numpy as np
    >>> from skimage.util.shape import view_as_windows
    >>> A = np.arange(4*4).reshape(4,4)
    >>> A
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    >>> window_shape = (2, 2)
    >>> B = view_as_windows(A, window_shape)
    >>> B[0, 0]
    array([[0, 1],
           [4, 5]])
    >>> B[0, 1]
    array([[1, 2],
           [5, 6]])

    >>> A = np.arange(10)
    >>> A
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> window_shape = (3,)
    >>> B = view_as_windows(A, window_shape)
    >>> B.shape
    (8, 3)
    >>> B
    array([[0, 1, 2],
           [1, 2, 3],
           [2, 3, 4],
           [3, 4, 5],
           [4, 5, 6],
           [5, 6, 7],
           [6, 7, 8],
           [7, 8, 9]])

    >>> A = np.arange(5*4).reshape(5, 4)
    >>> A
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15],
           [16, 17, 18, 19]])
    >>> window_shape = (4, 3)
    >>> B = view_as_windows(A, window_shape)
    >>> B.shape
    (2, 2, 4, 3)
    >>> B  # doctest: +NORMALIZE_WHITESPACE
    array([[[[ 0,  1,  2],
             [ 4,  5,  6],
             [ 8,  9, 10],
             [12, 13, 14]],
            [[ 1,  2,  3],
             [ 5,  6,  7],
             [ 9, 10, 11],
             [13, 14, 15]]],
           [[[ 4,  5,  6],
             [ 8,  9, 10],
             [12, 13, 14],
             [16, 17, 18]],
            [[ 5,  6,  7],
             [ 9, 10, 11],
             [13, 14, 15],
             [17, 18, 19]]]])
    z `arr_in` must be a numpy ndarrayz2`window_shape` is incompatible with `arr_in.shape`r   z`step` must be >= 1z*`step` is incompatible with `arr_in.shape`)dtyper   z`window_shape` is too largez`window_shape` is too smallc              3   8   K   | ]}t          d d |          V  d S )N)slice).0sts     r   	<genexpr>z"view_as_windows.<locals>.<genexpr>   s.      88R5tR((888888r   r   )r
   r   ndarrayr   r   numbersNumberlenr   r   r   r   r   r   r	   listr   )r   window_shapestepr   r   sliceswindow_stridesindexing_strideswin_indices_shaper   r	   r   s               r   r   r   `   s   ^ fbj)) <:;;;;D,// .$-%%MNNN$'' !882333w~
4yyDEFFF&&I8L	@@@L	\	!Q&++-- 86777		Q##%% 86777 88488888FXfn--Nf~- 
&,		"(<"8"8	8RXd^^K	
 d,--\0B0BBCCID)**T.-A-AABBGy'BBBGNr   )r   )r%   numpyr   numpy.lib.stride_tricksr   __all__r   r    r   r   <module>r3      sn         . . . . . ..
/U U UpW W W W W Wr   