Wsrtjtyk

I'm starting to use numpy. I get the slice notations & the element-wise computations, but I can't seem to wrap my head around this:

for i, (I,J) in enumerate(zip(data_list[0], data_list[1])):

    joint_hist[int(np.floor(I/self.bin_size))][int(np.floor(J/self.bin_size))] += 1

Variables:

data_list contains 2 np.array().flatten() images (eventually more)

joint_hist is displayed later with plt.imshow() and is the joint histogram of those 2 images

bin_size is the number of slots in the histogram

What I can't wrap my head around is the fact that the coordinate in the final histogram is I,J. So it's not just that the value at a position in joint_hist is the result of some slicing/element-wise computation. I need to take the result of that computation and use THAT as the indices in joint_hist...

EDIT:

I indeed do not use the i in the loop actually - it's a leftover from previous iterations and I simply hadn't noticed I didn't need it anymore

I do want to remain in control of the bin sizes & the details of how this is done, so not particularly looking to use histogramm2D. I will later be using that for further image processing, so I'd rather have the flexibility to adapt my approach than have to figure out if/how to do particular things with built-in functions.

You can indeed gussy up that for loop using some numpy notation. Assuming you don't actually need i (since it isn't used anywhere):

for I,J in (data_list.T // self.bin_size).astype(int):

    joint_hist[I, J] += 1

Explanation

data_list.T flips data_list on its side. Each row of data_list.T will contain the data for the pixels at a particular coordinate.

data_list.T // self.bin_size will produce the same result as np.floor(I/self.bin_size), only it will operate on all of the pixels at once, instead of one at a time.

.astype(int) does the same thing as int(...), but again operates on the entire array instead of a single element.

When you iterate over a 2D array with a for loop, the rows are returned one at a time. Thus, the for I,J in arr syntax will give you back one pair of pixels at a time, just like your zip statement did originally.

Alternative

You could also just use histogramdd to calculate joint_hist, in place of your for loop. For your application it would look like:

import numpy as np



joint_hist,edges = np.histogramdd(data_list.T)

This would have different bins than the ones you specified above, though (numpy would determine them automatically).

If I understand, your goal is to make an histogram or correlated values in your images? Well, to achieve the right bin index, the computation that you used is not valid. Instead of np.floor(I/self.bin_size), use np.floor(I/(I_max/bin_size)).astype(int). You want to divide I and J by their respective resolution. The result that you will get is a diagonal matrix for joint_hist if both data_list[0] and data_list[1] are the same flattened image.

So all put together:

I_max = data_list[0].max()+1

J_max = data_list[1].max()+1

joint_hist = np.zeros((I_max, J_max))

bin_size = 256

for i, (I, J) in enumerate(zip(data_list[0], data_list[1])):

    joint_hist[np.floor(I / (I_max / bin_size)).astype(int), np.floor(J / (J_max / bin_size)).astype(int)] += 1