Início / coding / Perguntas / 78478825
Accepted
Basj
Asked: 2024-05-14 22:36:38 +0800 CST

Fatiamento Numpy em uma matriz 2D com preenchimento de zeros

  • 772

Dado um array Numpy 2D, gostaria de poder preenchê-lo nos lados esquerdo, direito, superior e inferior, como o pseudocódigo a seguir. Já existe algo assim integrado ao Numpy?

import numpy as np

a = np.arange(16).reshape((4, 4))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]]

pad(a)[-4:2, -1:3]   # or any syntax giving the same result

#[[0 0 0 0]
# [0 0 0 0]
# [0 0 0 0]
# [0 0 0 0]
# [0 0 1 2]
# [0 4 5 6]]

pad(a)[-4:2, -1:6]

#[[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 1 2 3 0 0]
# [0 4 5 6 7 0 0]]
python

3 respostas

  1. Best Answer

    Alguns truques:

    import numpy as np

class PaddedArray:
    def __init__(self, arr):
        self.arr = arr
    def __getitem__(self, idx):
        idx = tuple(
            slice(s.start or 0, s.stop or size)
            for size, s in zip(self.arr.shape, idx)
        )
        slices = tuple(
            slice(max(0, s.start), min(size, s.stop))
            for size, s in zip(self.arr.shape, idx)
        )
        paddings = tuple(
            (max(0, -s.start), max(0, s.stop - size))
            for size, s in zip(self.arr.shape, idx)
        )
        return np.pad(self.arr[slices], paddings)

    Teste:

    >>> PaddedArray(np.arange(16).reshape((4, 4)))[-4:2, -1:3]
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 1, 2],
       [0, 4, 5, 6]])
>>> PaddedArray(np.arange(16).reshape((4, 4)))[-4:2, -1:6]
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, 1, 2, 3, 0, 0],
       [0, 4, 5, 6, 7, 0, 0]])
>>> PaddedArray(np.arange(32).reshape((4, 4, 2)))[-4:2, -1:3, :]
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,  1],
        [ 2,  3],
        [ 4,  5]],

       [[ 0,  0],
        [ 8,  9],
        [10, 11],
        [12, 13]]])
    • 6

  2. Você pode definir uma matriz de zeros do tamanho correto e depois copiar a fatia da sua matriz:

    def pad(array: np.ndarray, row_slice: tuple[int], col_slice: tuple[int]) -> np.ndarray:
    arows, acols = array.shape
    
    take_rows = slice(max(0, row_slice[0]), min(arows, row_slice[1]))
    take_cols = slice(max(0, col_slice[0]), min(acols, col_slice[1]))
    take_arr = array[take_rows, take_cols]
    t_start_row = abs(min(0, row_slice[0]))
    t_start_col = abs(min(0, col_slice[0]))

    rrows = row_slice[1] - row_slice[0]
    rcols = col_slice[1] - col_slice[0]

    z = np.zeros((rrows, rcols))
    z[t_start_row:t_start_row + take_arr.shape[0], t_start_col:t_start_col + take_arr.shape[1]] = take_arr

    return z

    AFAIK, não há como usar a sintaxe da fatia pad(a, -4:2, -1:6)fora de uma operação de indexação, mas esta função permite especificar as fatias como tuplas, o que acho que é próximo o suficiente da sintaxe desejada

    • 2

  3. Você não pode usar o fatiamento para isso, os números negativos têm um significado diferente em uma fatia.

    Você teria que usar pad:

    np.pad(a[:2, :3], ((4, 0), (1, 0)), constant_values=0)

array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 1, 2],
       [0, 4, 5, 6]])

np.pad(a[:2, :], ((4, 0), (1, 6-a.shape[1])), constant_values=0)

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, 1, 2, 3, 0, 0],
       [0, 4, 5, 6, 7, 0, 0]])

    Abordagem genérica usando uma função:

    def pad(a, top=0, bottom=0, left=0, right=0):
    T = max(top, 0)
    B = min(bottom, a.shape[0])
    L = max(left, 0)
    R = min(right, a.shape[1])
    pT = -min(top, 0)
    pB = max(bottom-a.shape[0], 0)
    pL = -min(left, 0)
    pR = max(right-a.shape[1], 0)
    return np.pad(a[T:B, L:R], ((pT, pB), (pL, pR)), constant_values=0)

pad(a, -4, 2, -1, 3)

array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 1, 2],
       [0, 4, 5, 6]])

pad(a, -4, 2, -1, 6)

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, 1, 2, 3, 0, 0],
       [0, 4, 5, 6, 7, 0, 0]])
    • 1

relate perguntas