4

Let's say I have a numpy array of rgb-imagetype looking like this:

d = [ [ [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, 25 ,26] ] ]

I select a few random r/g or b pixels using random

import random
r = random.sample(range(1, len(d)*len(d[0])*3), 3)
# for example r = [25, 4, 15]

How can I then select the data I want?

Like I want 25th value in array d for the first r_value = 25 which corresponds to d[2][2][1], because it is the 25th value.

Improve this question
0

5 Answers 5

Reset to default
5

What you want to do is index it as a flat or 1d array. There are various ways of doing this. ravel and reshape(-1) create 1d views, flatten() creates a 1d copy.

The most efficient is the flat iterator (an attribute, not method):

In [347]: d.flat[25]
Out[347]: 25

(it can be used in an assignment as well, eg. d.flat[25]=0.

In [341]: idx = [25, 4, 15]
In [343]: d.flat[idx]
Out[343]: array([25,  4, 15])

To find out what the 3d index is, there's utility, unravel_index (and a corresponding ravel_multi_index)

In [344]: fidx=np.unravel_index(idx,d.shape)
In [345]: fidx
Out[345]: 
(array([2, 0, 1], dtype=int32),
 array([2, 1, 2], dtype=int32),
 array([1, 1, 0], dtype=int32))
In [346]: d[fidx]
Out[346]: array([25,  4, 15])

This a tuple, the index for one element is read 'down', e.g. (2,2,1).

On a large array, flat indexing is actually a bit faster:

In [362]: dl=np.ones((100,100,100))
In [363]: idx=np.arange(0,1000000,40)
In [364]: fidx=np.unravel_index(idx,dl.shape)
In [365]: timeit x=dl[fidx]
1000 loops, best of 3: 447 µs per loop
In [366]: timeit x=dl.flat[idx]
1000 loops, best of 3: 312 µs per loop
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Very useful answer with some more numpy tools I didn't know of. Thank you
3

If you are going to inspect/alter the array linearly on a frequent basis, you can construct a linear view:

d_lin = d.reshape(-1)  # construct a 1d view
d_lin[25]         # access the 25-th element

Or putting it all in a one-liner:

d.reshape(-1)[25]  # construct a 1d view

You can from now on access (and modify) the elements in d_view as a 1d array. So you access the 25-th value with d_lin[25]. You don't have to construct a new view each time you want to access/modify an element: simply reuse the d_lin view.

Furthermore the order of flattening can be specified (order='C' (C-like), order='F' (Fortran-like) or order='A' (Fortran-wise if contiguous in meory, C-like otherwise)). order='F' means that we first iterate over the greatest dimension.

The advantage of a view (but this can also lead to unintended behavior), is that if you assign a new value through d_lin, like d_lin[25] = 3, it will alter the original matrix.

Alternatives are .flat, or np.ravel. So the following are somewhat equivalent:

d.reshape(-1)[25]
np.ravel(d)[25]
d.flat[25]

There are however some differences between the reshape(..) and ravel(..) approach against the flat approach. The most important one is the fact that d.flat does not create a full view. Indeed if we for instance want to pass the view to another function that expects a numpy array, then it will crash, for example:

>>> d.flat.sum()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'numpy.flatiter' object has no attribute 'sum'
>>> d.reshape(-1).sum()
351
>>> np.ravel(d).sum()
351

This is not per se a problem. If we want to limit the number of tools (for instance as a protection mechanism), then this will actually give us a bit more security (although we can still set elements elements in bulk, and call np.sum(..) on an flatiter object).

Improve this answer

5 Comments

This is exaxtly what I wanted, since I want to alter the original matrix. Thank you
With the flat iterator, I don't think there's any speed advantage to constructing a separate view. d.flat indexing may actually be faster than the unraveled equivalent.
@hpaulj: I think the advantage of a view is that it "acts" like an array. You can for instance calculate the sum() over it, or inspect the shape. This can be useful if you for instance have some methods that work on array-like objects. In other words, one can treat it as 1d array as if it was never a 3d array.
I think hpaulj's answer below is probably a better solution than this, numpy.flat makes this 3 liner into a single attribute reference
@LouisMaddox: furthermore something that was noted in the comments, and now in the answer, is that d.flat does not produce a fully flat view of the array. For instance we can not calculate the .sum() of .flat. This can be problematic if we want to pass a flat view to a function, and that function expects an array-like object. With .flat, it will return a flatiter object, which has a more limited number of tools.
0

You can use numpy.flatten method, like this:

a = np.array(d)
d[25] # print 26
Improve this answer

Comments

0

Assuming you do not want to flatten your array: if you know the size of the sublists beforehand, you can easily calculate it out. In your example, every element of the main list is a list of exactly 3 elements, each element containing 3. So to access n you could do something like

i = n//9 j = (n%9)//3 k = (n%3) element = d[i][j][k]

For n=25, you'd get i = 2, j = 2, k = 1, just as you wanted.

In python2, you can (and have to) use the normal / operator instead of //

Improve this answer

1 Comment

np.unravel_index does this calculation.
-1

If you only care on the value, you can flatten your array, and access it directly as

val = d.flatten()[r]

If you really want the index corresponding to the flattened index, you need to something like this:

ix_2 = r % d.shape[2]
helper_2 = (r - ix_2) / d.shape[2]
ix_1 = helper_2 % d.shape[1]
helper_1 = (helper_2 - ix_1) / d.shape[1]
ix_0 = helper_1 % d.shape[0]

val = d[ix_0, ix_1, ix_2]
Improve this answer

1 Comment

flatten() produces a copy, not a view.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.