numpy - comment découper un tableau en passant par la limite du tableau et en revenant au début.

Question

J'ai une image dans un tableau numpy et je veux prendre la tranche en rouge.

Je m'attends à ce que la sortie ressemble à ceci.

Imaginez que la forme est [600,800,3].

J'ai essayé img[200:400,400:900,:] le 900 étant plus haut que la limite en espérant qu'il s'enroule autour mais non.

Je sais que je pourrais aussi le prendre en deux tranches et les empiler, mais je ne peux m'empêcher de penser qu'il y a une meilleure façon de faire ?

Il est également possible que la tranche déborde horizontalement ou verticalement ou les deux.

Des suggestions ?

Answer 1

Vous pourriez utiliser np.roll() qui effectue une permutation cyclique / un décalage cyclique, le long de l'axe (ou des axes) spécifié(s).

Si le décalage se fait uniquement sur l'axe 1, utilisez :

new_img = np.roll (img, split, axis=1)

donde split est la valeur de col à laquelle votre image doit être divisée. L'effet de ce décalage cyclique est exactement comme si l'image avait été divisée au point spécifié sur l'axe, et que les deux parties de l'image résultantes avaient été échangées.

Puisque vous avez besoin de décaler le long de l'axe 1, et simultanément de découper le long de l'axe 0, ce serait :

new_img = np.roll (img[low:high,...], split, axis=[0,1])

donde low y high sont des limites de tranche appropriées le long de l'axe 0.

Si un changement peut se produire le long les deux axes simultanément (et il y a sur le tranchage), ce serait :

new_img = np.roll (img, [split_0, split_1], axis=[0,1])

donde split_0 est le point de séparation le long de l'axe0 et split_1 est le point de séparation le long de l'axe1

Nota: De manière assez surprenante, au lieu de renvoyer une vue, roll() renvoie un copie Il n'y a donc pas d'avantage en termes de vitesse par rapport à l'empilage et à la concaténation.

Answer 2

Essayez ceci :

the_red_slice = np.tile(img, (1, 2, 1))[200:400,400:900,:]

El tile doit dupliquer l'image à la deuxième dimension pour que vous puissiez l'indexer. La zone rouge ne doit pas être supérieure à la largeur de l'image pour que cette solution fonctionne. voir : docs numpy : tuile

Answer 3

Note : Raison de la publication de cette réponse supplémentaire :

Je me suis rendu compte un peu tard que le fait de considérer ce problème uniquement comme un problème de "décalage" ne répond pas entièrement à l'exigence, car, après le décalage, la longueur de l'image le long de l'axe décalé reste la même qu'avant, alors que l'exigence est que le long de l'axe1, le décalage et le découpage doivent tous deux se produire.

Laissez :

• L_0 soit la longueur de l'image le long de l'axe0 (dans votre exemple, 600 )
• L_1 être la longueur de l'image le long de l'axe1 (dans votre exemple, 800 )
• low_0:high_0 soit la tranche requise le long de l'axe0 (dans votre exemple, c'est probablement 200:500 )
• low_1:high_1 être la tranche requise le long de l'axe1 (dans votre exemple, c'était 200:900 )

Solution :

# Re-compute slice-lengths, slice-starts, for both axes
len_0 = (high_0 - low_0) % L_0          # slice-length for axis0
len_1 = (high_1 - low_1) % L_1          # slice-length for axis1
low_0 = (low_0 % L_0)
low_1 = (low_1 % L_1)

new_img = np.roll(img, [-1 * low_0, -1 * low_1], axis=(0,1)) [:len_0, :len_1, :]

Explication :

Ce que nous faisons essentiellement, ce sont les étapes suivantes :

1. Calcul de la longueur "réelle" de la tranche le long de chaque axe ( len_0 , len_1 )
2. Déplacement vers le haut de l'image de façon cyclique, en low_0 (le -1 signifie vers le haut)
3. Déplacement vers la gauche de l'image de manière cyclique, en low_1 (le -1 signifie vers la gauche)
4. Sur l'image décalée en appliquant la tranche :len_0 le long de l'axe0, et la tranche :len_1 le long de l'axe1, et la tranche complète : pour l'axe 2