3

I have a numpy array in python 2.7, which I am using the imshow() function to visualise. The code generating the array looks like:

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()

What this does is produce an image with a level of background noise, and one circularly symmetric source. There is a circle centred on the image, with a radius of 40 pixels.

What I need to know is how to find the location of the highest value pixel within that circle. I know how to find the maximum value in the circle, but not the [i,j] location of it.

Thank you!

My question has been flagged by stackoverflow as a potential duplicate, but this doesn't contain the location restrictions that I need.

Dan Pollard
  • 51
  • 1
  • 7
  • 2
    What method are you using to find the max value of the circle? – SeeDerekEngineer Jul 20 '17 at 15:07
  • I have a list which starts empty, and then a for loop goes through the array appending every value to the list, skipping values outside the circle. It then prints the maximum value in that list. – Dan Pollard Jul 20 '17 at 15:07
  • If I am understanding correctly then, ill post an answer that should work. Let me know and I will adjust accordingly. – SeeDerekEngineer Jul 20 '17 at 15:51

2 Answers2

5

One solution is to "zero" out all the elements surrounding the circle and then simply take the max of the entire array. It appears your radius is 41, centered at (50,50).

Then you could do

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

And now create your image. Then find the minimum value and set that to every value out side your boundary. If there is a pixel outside the circle that is bigger than the max inside the circle, it is now set to a much smaller value.

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

So your image will look like

enter image description here

And now just take the max

print np.max(x)
6.4648628255130571

This solution is nice because it avoids loops, which pretty much defeats the purpose of using numpy in the first place.

EDIT:

Sorry you said you wanted the indices of the max. The above solution is the same just unravel the index.

>>> i, j = np.unravel_index(x.argmax(), x.shape)
>>> print "{} {}".format(i, j)
23 32
>>> np.max(x) == x[i,j]
True
o-90
  • 17,045
  • 10
  • 39
  • 63
0
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

should do it.

SeeDerekEngineer
  • 770
  • 2
  • 6
  • 22