3
votes

Comparer le tableau numpy booléen des voisins dans la grille

Je veux écrire une fonction qui compare les 8 voisins d'un nœud dans ma grille. Lorsque au moins 3 des voisins ont la même valeur que le nœud central, nous pouvons définir le nœud comme heureux.

par exemple dans ce tableau le nœud central et la valeur est 0, on voit qu'il a 3 voisins de 0, donc le nœud est content:

def nodehappiness(grid, i, j, drempel=3):
    if i,j => 3:
       node == True

J'attends un sortie booléenne avec True ou False.

Puis-je penser à quelque chose comme ça ou puis-je utiliser facilement numpy pour cela?

 array([[ 1,  0,  1],
       [ 1,  0,  1],
       [-1,  0,  0]])

Merci d'avance

python python-3.x arrays numpy numpy-ndarray

4 commentaires

Peut-être cherchez-vous quelque chose du genre de ndimage.generic_filter (arr, f, footprint = footprint, mode = 'wrap') de scipy ? Voir ici .

Également pertinent: np.pad (arr, pad_width = 1, mode = 'wrap')

l'indexation numpy vous permet en fait d'utiliser -1 comme index pour la dernière entrée. De cette façon, vous n'avez pas besoin d'utiliser des fonctions telles que generic_filter` ou pad

L'ordre de la liste de résultats est-il pertinent?

4 Réponses :

0
votes

Vous recherchez quelque chose comme ça?

def neighbour(grid, i, j):
    return np.delete((grid[i-1:i+2,j-1:j+2]).reshape(1,9),4)

# Test code
grid = np.arange(16).reshape(4,4)

b = neighbour(m, 2, 2)

0 commentaires

1
votes

Essayez ceci:

x = np.array([0,1,2,3])
x[-1]
# 3

x.reshape((2,2))
#array([[0, 1],
#       [2, 3]])

x[-1,-1]
# 3

Modifier: Exemple

grid = np.arange(25).reshape((5,5))
#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]])

neighbours(grid, 0, 0)
# array([24, 20, 21,  4,  1,  9,  5,  6])

Explication strong >:

Avec numpy vous pouvez utiliser des indices négatifs vous permettant d'accéder facilement aux dernières entrées d'un tableau. Cela fonctionnera également pour plusieurs dimensions:

def neighbours(grid, i, j):
    rows = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
    cols = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
    return grid[rows+i,cols+j]

Vous êtes intéressé par 8 entrées de la matrice.

à gauche au-dessus -> ligne - 1, colonne - 1
ci-dessus -> ligne - 1, colonne + 0
juste au-dessus -> ligne - 1, colonne + 1
gauche -> ligne + 0, colonne - 1
...

C'est ce que représentent les tableaux lignes et cols . En ajoutant i et j vous obtenez toutes les entrées autour de ces coordonnées.

6 commentaires

Merci pour votre réponse, mais j'ai besoin d'une fonction globale que je peux utiliser pour chaque grille. Il doit envelopper chaque grille que je définis

Je ne comprends pas très bien le problème. Vous pouvez appeler ma fonction voisins sur n'importe quelle grille 2D.

Je ne comprends pas votre code. Parce qu'il ne donne pas mon résultat attendu. Que faites-vous avec le np.array dans les lignes et les cols? Je n'obtiens pas mes résultats escomptés. Pouvez-vous expliquer votre code?

Bien sûr, je vais éditer et expliquer. Juste pour clarifier, pourriez-vous me dire quel serait le résultat attendu dans mon exemple?

Non j'obtiens maintenant le résultat attendu, merci d'avance! Mais pouvez-vous expliquer ce que vous avez fait?

Ok, je vais ajouter une explication

0
votes

Essayez ceci.

y=[]
l= len(x)
for i in range(0,l):
    for j in range(0,l):
        if i==int(l/2) and j==int(l/2):
            continue
        y.append(x[j,i])

0 commentaires

0
votes

Certains piratages utilisant ndimage.generic_filter :

[[8 6 7 8 6]
 [2 0 1 2 0]
 [5 3 4 5 3]
 [8 6 7 8 6]
 [2 0 1 2 0]]

Qui imprime:

padded = np.pad(arr, pad_width=1, mode='wrap')
print(padded)

Si vous voulez simplement le rembourrage array:

# neighbors
[[8. 6. 7. 2. 1. 5. 3. 4.]
 [6. 7. 8. 0. 2. 3. 4. 5.]
 [7. 8. 6. 1. 0. 4. 5. 3.]
 [2. 0. 1. 5. 4. 8. 6. 7.]
 [0. 1. 2. 3. 5. 6. 7. 8.]
 [1. 2. 0. 4. 3. 7. 8. 6.]
 [5. 3. 4. 8. 7. 2. 0. 1.]
 [3. 4. 5. 6. 8. 0. 1. 2.]
 [4. 5. 3. 7. 6. 1. 2. 0.]]

# neighbors_grid
[[[8. 6. 7. 2. 1. 5. 3. 4.]
  [6. 7. 8. 0. 2. 3. 4. 5.]
  [7. 8. 6. 1. 0. 4. 5. 3.]]

 [[2. 0. 1. 5. 4. 8. 6. 7.]
  [0. 1. 2. 3. 5. 6. 7. 8.]
  [1. 2. 0. 4. 3. 7. 8. 6.]]

 [[5. 3. 4. 8. 7. 2. 0. 1.]
  [3. 4. 5. 6. 8. 0. 1. 2.]
  [4. 5. 3. 7. 6. 1. 2. 0.]]]

Ce qui donne bien sûr:

from scipy import ndimage

def get_neighbors(arr):
    output = []
    def f(x):
        output.append(x)
        return 0

    t = tuple(int((x - 1) / 2) for x in arr.shape)
    footprint = np.ones_like(arr)
    footprint[t] = 0
    ndimage.generic_filter(arr, f, footprint=footprint, mode='wrap')
    return np.array(output)

arr = np.arange(9).reshape(3, 3)
neighbors = get_neighbors(arr)
neighbors_grid = neighbors.reshape(*arr.shape, -1)

print(neighbors)
print(neighbors_grid)

0 commentaires