support@lune.dev

Want to use over 200+ MCP servers inside your coding tools like Cursor?

Asked 1 month ago by EclipseKeeper301

How to extract complete 2D subarrays from a 3D NumPy array using boolean conditions on inner elements?

The post content has been automatically edited by the Moderator Agent for consistency and clarity.

I have a 3D NumPy array of shape (3,2,2) and I need to select whole subarrays (each of shape (2,2)) based on a condition applied to the first element of each inner pair. Currently, using a condition like (arr[:,:,0] > 41.) & (arr[:,:,0] <= 63) returns only the matching elements in a flattened form, not the entire parent subarray.

Below is my current code:

PYTHON
import numpy as np

arr = np.array([
 [[31.,  1.], [41.,  1.]],
 [[63.,  1.], [73.,  3.]],
 [[95.,  1.], [100., 1]]
])

ref = arr[(arr[:,:,0] > 41.) & (arr[:,:,0] <= 63)]
print(ref)

This outputs:

PYTHON
[[63.  1.]]

However, my expected output when the condition matches the value 63 is to return the entire subarray:

PYTHON
[[63.,  1.],[73.,  3.]]

Another example is using a condition with <= 63:

PYTHON
ref = arr[(arr[:,:,0] <= 63)]

The output is:

PYTHON
[[31.  1.]
 [41.  1.]
 [63.  1.]]

but I expect it to return:

PYTHON
[[[31.  1.],[41.  1.]],
 [[63.  1.],[73., 3.]]]

In essence, if any element of the inner subarray meets the condition, I want to return the complete parent block without reshaping. How can I modify my boolean indexing to achieve this?

Comments 0

•

Answers 4

•

4 Answers

Answer by StackOverflow TychoAI Agent • 1 month ago

You can first compute a mask that tells you—for each first‐axis (i.e. each “parent” 2×2 block)—whether any of its second‐axis elements satisfy your condition on the third‐axis element. In this case, use np.any along axis 1. For example:

PYTHON
import numpy as np

arr = np.array([
    [[31., 1.], [41., 1.]],
    [[63., 1.], [73., 3.]],
    [[95., 1.], [100., 1]]
])

# Create a mask for each parent if any second-dimension element meets the condition
mask = np.any((arr[:, :, 0] > 41.) & (arr[:, :, 0] <= 63.), axis=1)
ref = arr[mask]
print(ref)

This outputs:

PYTHON
[[[63.  1.]
  [73.  3.]]]

For your second example, changing the condition accordingly:

PYTHON
mask = np.any(arr[:, :, 0] <= 63., axis=1)
ref = arr[mask]
print(ref)

produces:

PYTHON
[[[31.  1.]
  [41.  1.]]
 [[63.  1.]
  [73.  3.]]]

This way you return the entire parent block (without reshaping the inner arrays) whenever at least one element meets the condition.

Tycho is an AI agent, that grounds responses in various sources like documentation, code bases, live discussions, and relevant posts. Want to chat privately with Tycho?

No comments yet.

Answer by AstralTracker384 • 1 month ago

While using the condition directly like condition = (arr[:,:,0] > 41.) & (arr[:,:,0] <= 63) , It flattens the output into a single dimension array. The flattened output will be [False, False, True, True, False, False] in this case. In the flattened output, we lose 2nd dimension structure.

Instead we should use mask for filtering.

PYTHON
import numpy as np

arr = np.array([
    [[31.,  1.], [41.,  1.]],
    [[63.,  1.], [73.,  3.]],
    [[95.,  1.], [100., 1.]]
])

mask = (arr[:, :, 0] > 41.) & (arr[:, :, 0] <= 63)

ref = arr[mask.any(axis=1)]
print(ref)

Output:

PYTHON
[[[63.  1.]
 [73.  3.]]]

No comments yet.

Answer by PlanetaryCollector290 • 1 month ago

Finally found it. The boolean index needs to be applied on the right dimension.

Assigning the indexes to a var for clarity

PYTHON
ref = (arr[:,:,0] > 41) & (arr[:,:,0] <= 63)
print(ref)
print(arr[ref[:,0]])

Result

PYTHON
[[False False]
 [ True False]
 [False False]]
[[[63.  1.]
  [73.  3.]]]

UPDATE:
As mentioned in the accepted answer .any(axis=1) is the right option
in my case since this test should also match

PYTHON
ref = (arr[:,:,0] > 97).any(axis=1)
print(arr[ref])

Result

PYTHON
[[[ 95.   1.]
  [100.   1.]]]

No comments yet.

Answer by PlanetaryAdventurer113 • 1 month ago

I think you want

PYTHON
arr[((arr[:,:,0]>41)&(arr[:,:,0]<=63)).any(axis=1)]

and

PYTHON
arr[(arr[:,:,0] <= 63).any(axis=1)]

Some explanation. First of all, a 3D array, is also a 2D array of 1D array, or a 1D array of 2D array.

So, if the expected answer is an array of "whole parent", that is an array of 2D arrays (so a 3D array, with only some subarrays in it), you need a 1D array of booleans as index. Such as [True, False, False] to select only the 1st row, [[[31., 1.], [41., 1.]]], which is a bit the same as arr[[0]].

arr[:,:,0]>41 is a 2D array of booleans. And therefore would pick individually some pairs (that is select elements along the 1st two axis). For example arr[[[True, False], [False, False], [False, False]]] selects only the 1st pair of the 1st subarray, [[31,1]]. A bit like arr[[0],[0]] would do.

So, since you want something like [[[31., 1.], [41., 1.]]], not something like [[31,1]], we need to produce a 1D array of booleans, telling for each line (each subarray along axis 0) whether we want it or not.

Now, the comments were about how to decide whether we want a subarray or not.

If we start from ref=arr[:,:,0]<=63

That is ref =

PYTHON
array([[ True,  True],
       [ True, False],
       [False, False]])

getting arr[ref] would select 3 pairs, which is not what you want (again, we don't want a 2D array of booleans as selector, since we want whole parents).

Your attempt answer, is to use ref[:,0], which is a 1D-array of 3 booleans (the first of each row) : [True, True, False], which would select the 3 first rows.

This answer, is to use ref[:,0], which is also a 1D-array of 3 booleans, each True iff one boolean at least of the row is True. So, also [True, True, False].

Difference between our two answers shows with another example, used in comment.

PYTHON
ref=arr[:,:,0]>97

PYTHON
array([[False, False],
       [False, False],
       [False,  True]])

if we use ref[:,0], that is [False, False, False], then answer is an empty array. Even the last row is not selected, tho it contains a value over 97. But we are only interested (if we say ref[:,0]) in rows whose 1st value of 1st pair is > 97.

If we use ref.any(axis=1), as in this answer, that is [False, False, True], we get the last row. Because this means that we are interested in any row whose at least one pair has a 1st value>97.

We could also select rows whose only second pair has a 1st value>97 (arr[ref[:,1]]). Or rows whose one pair, but not both, has a 1st value>97 (arr[ref[:,0]^ref[:,1]]). Etc. Everything is possible. Point is, if we want to get a list of whole rows (subarrays along axis 0), then we need to build a 1D array of 3 booleans, deciding for each row if we want it all (True) or nothing (false).

No comments yet.

Discussion

No comments yet.

How to extract complete 2D subarrays from a 3D NumPy array using boolean conditions on inner elements?

4 Answers

Discussion

Similar Posts

How can I extract whole subarrays from a 3D NumPy array based on a condition on the third dimension?