Comment trouver la valeur maximale d'un tableau numpy, avec des restrictions de localisation ?

Question

J'ai un tableau numpy en python 2.7, que j'utilise la fonction imshow() pour le visualiser. Le code générant le tableau ressemble à ceci :

from pylab import *
r0 = 3.0
S0 = 10.0
x = zeros((101,101))
noiseimg = zeros((101,101))
for i in range(101):
    for j in range(101):
        noiseimg[i,j] = noiseimg[i,j] + normal(3,1)
mean_i = randint(0,101)
mean_j = randint(0,101)

for i in range(101):
    for j in range(101):
        r = ((i-mean_i)**2 + (j-mean_j)**2)**0.5
        x[i,j] = S0*(1+(r/r0)**2)**-1.5
        x[i,j] = x[i,j] + noiseimg[i,j]
        if (((i-50)**2 + (j-50)**2)**0.5 >= 40) and (((i-50)**2 + (j-50)**2)**0.5 <= 41):
            x[i,j]=0
imshow(x)
show()

Cela permet de produire une image avec un niveau de bruit de fond et une source à symétrie circulaire. Un cercle centré sur l'image a un rayon de 40 pixels.

Ce que je voudrais savoir, c'est comment trouver l'emplacement du pixel ayant la valeur la plus élevée à l'intérieur de ce cercle. Je sais comment trouver la valeur maximale dans le cercle, mais pas l'emplacement du pixel le plus élevé. [i,j] l'endroit où il se trouve.

Merci de votre attention !

Ma question a été signalée par stackoverflow comme étant un doublon potentiel mais il ne contient pas les restrictions de localisation dont j'ai besoin.

Answer 1

Une solution consiste à mettre à zéro tous les éléments entourant le cercle, puis à prendre la valeur maximale de l'ensemble du tableau. Il semble que votre rayon soit de 41, centré sur (50,50).

Vous pouvez alors faire

import numpy as np

xc, yc = 50, 50
length = 101
radius = 41

y_grid, x_grid = np.ogrid[-xc:length-xc, -yc:length-yc]
mask = x_grid ** 2 + y_grid ** 2 > radius ** 2

Et maintenant, créez votre image. Trouvez ensuite la valeur minimale et définissez-la pour chaque valeur en dehors de votre limite. Si un pixel à l'extérieur du cercle est plus grand que la valeur maximale à l'intérieur du cercle, il est maintenant défini à une valeur beaucoup plus petite.

x_min = np.min(x)
x[mask] = x_min

Votre image aura donc l'aspect suivant

Et maintenant, prenez le maximum

print np.max(x)
6.4648628255130571

Cette solution est intéressante car elle permet d'éviter les boucles, ce qui va à l'encontre du but recherché par l'utilisation de numpy.

EDIT :

Désolé, vous avez dit que vous vouliez les indices du maximum. La solution ci-dessus est la même, il suffit de démêler l'indice.

>>> i, j = np.unravel_index(x.argmax(), x.shape)
>>> print "{} {}".format(i, j)
23 32
>>> np.max(x) == x[i,j]
True

Answer 2

circleList = []
indeces = []
for i in len(x[0]):
    for j in len(x[1]):
        if x[i,j] in circle:    #However you check if pixel is inside circle
            circleList.append(x[i,j])
            indeces.append = ((i,j))
print np.max(circleList)              #Here is your max
print indeces(np.argmax(circleList))  #Here are the indeces of the max

devrait le faire.