KyroAsks's questions

Seria possível, dado um array A, índices de linha e índices de coluna ruins, usar o fatiamento para criar um novo array que não tenha essas linhas ou colunas?

Isso pode ser feito com np.delete da seguinte maneira:

import numpy as np
A=np.random.rand(20,16)
bad_col=np.arange(0,A.shape[1],4)[1:]
bad_row=np.arange(0,A.shape[0],4)[1:]
Anew=np.delete(np.delete(A,bad_row,0),bad_col,1)
print('old shape ',A.shape)
print('new shape ',Anew.shape)

Eu também sei que você pode usar fatiamento para selecionar certas colunas e linhas de um array. Mas eu estou pensando se ele pode ser usado para excluir certas colunas e linhas? E se não, qual a melhor maneira além np.deletede fazer isso.

EDIT: Com base nos comentários, pode não ser possível com o slicing no lugar. Que tal criar um novo array com indexação avançada?

Pode ser feito com o seguinte código, mas é lento, procure uma alternativa mais rápida:

good_col = [i for i in range(A.shape[1]) if i==0 or i % 4 != 0]
good_row=[ i for i in range(A.shape[0]) if i==0 or i % 4 != 0]

Anew2=A[good_row,:][:,good_col]
print('new shape ',Anew2.shape)

Obrigado

Dado um array 2D de tamanho (W,H), por exemplo (3,4). Você pode pensar em cada ponto nesse array 2D como um canto de um patch retangular. Eu quero dividir esse array em seus patches individuais, conforme mostrado no exemplo abaixo. A ordem pela qual essa divisão acontece é linha por linha e para cada patch começamos do pixel superior esquerdo e movemos no sentido anti-horário. Ou seja, o patch 1 é [A[0,0],A[1,0],A[1,1],A[0,1]]. Então o patch dois é [A[0,1],A[1,1],A[1,2],A[0,2]]. O número de patches é (w-1) (h-1) e a saída final é outro array 2D de tamanho ((w-1) ( h-1),4) (por exemplo, (6,4) aqui), onde 6 é o número de patches e 4 são valores de array para os cantos do patch no sentido anti-horário, conforme descrito acima.

Agora minha pergunta é sobre a maneira mais eficiente de produzir esses patches em python usando apenas funções python e numpy.

Muito obrigado.

Posso escrever um loop duplo for que faça o trabalho conforme abaixo, mas estou pensando se existe um algoritmo melhor que possa fornecer um desempenho mais rápido:

import numpy as np
A=np.array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
H=A.shape[0]
W=A.shape[1]
patches=[]
for y in range(H-1):
    for x in range(W-1):
       patches.append([A[0+y,0+x],A[1+y,0+x],A[1+y,1+x],A[0+y,1+x]])


patches =np.array(patches)
print(patches)

Dado um array 4D de tamanho (N,W,H,3), onde N é o número de patches, W,H são a largura e altura de um patch de imagem e 3 é o número de canais de cor. Suponha que esses patches foram gerados pegando uma imagem original I e ​​dividindo-a em pequenos quadrados. A ordem pela qual essa divisão acontece é linha por linha. Então, se dividirmos nossa imagem em patches 3x3 (9 no total), cada um com 10x10 pixels, então o array 4D será (9,10,10,3) e a ordem dos elementos nele será [patch11,patch12,patch13,patch21,patch22,patch23,patch31,patch32,patch33].

Agora, minha pergunta é sobre a maneira mais eficiente de combinar esses patches de volta para produzir a imagem original apenas em Python, usando apenas funções Python e numpy (sem PIL ou OpenCV).

Muito obrigado.

Posso escrever um loop duplo que faça o trabalho conforme abaixo, mas estou pensando se existe um algoritmo melhor que possa fornecer um desempenho mais rápido:

import numpy as np

def reconstruct_image(patches, num_rows, num_cols):
    # num_rows and num_cols are the number of patches in the rows and columns respectively
    patch_height, patch_width, channels = patches.shape[1], patches.shape[2], patches.shape[3]

    # Initialize the empty array for the full image
    full_image = np.zeros((num_rows * patch_height, num_cols * patch_width, channels), dtype=patches.dtype)

    # Iterate over the rows and columns of patches
    for i in range(num_rows):
        for j in range(num_cols):
            # Get the index of the current patch in the 4D array
            patch_index = i * num_cols + j
            # Place the patch in the appropriate position in the full image
            full_image[i*patch_height:(i+1)*patch_height, j*patch_width:(j+1)*patch_width, :] = patches[patch_index]

    return full_image

N = 9  # Number of patches
W, H, C = 10, 10, 3  # Patch dimensions (WxHxC)
num_rows, num_cols = 3, 3  # Number of patches in rows and columns (3x3 patches)
patches = np.random.rand(N, W, H, C)  # Example patch data

reconstructed_image = reconstruct_image(patches, num_rows, num_cols)