Here is a solution in Java that gives you both:

• from 3D to 1D
• from 1D to 3D

Below is a graphical illustration of the path I chose to traverse the 3D matrix, the cells are numbered in their traversal order:

Conversion functions:

public int to1D( int x, int y, int z ) {
    return (z * xMax * yMax) + (y * xMax) + x;
}

public int[] to3D( int idx ) {
    final int z = idx / (xMax * yMax);
    idx -= (z * xMax * yMax);
    final int y = idx / xMax;
    final int x = idx % xMax;
    return new int[]{ x, y, z };
}

You can achieve this with this piece of code:

import numpy as np
arr = np.random.randn(100, 5, 2)
ids = np.random.randint(0, 5, size=100)
res = arr[range(100), ids]
res.shape # (100, 2)

This depends on that how you want to order your 3D data in 1D array, if you wanted to have indexes in order: Z, Y, X then your 2x2x2 dimensioned 3D data will be stored like this:

index 0: [z=0,y=0,x=0]
index 1: [z=0,y=0,x=1]
index 2: [z=0,y=1,x=0]
index 3: [z=0,y=1,x=1]
index 4: [z=1,y=0,x=0]
index 5: [z=1,y=0,x=1]
index 6: [z=1,y=1,x=0]
index 7: [z=1,y=1,x=1]

DEPTH dimension corresponds to z, HEIGHT to y and WIDTH to x

The index calculation will be: index = HEIGHT*WIDTH*z + WIDTH*y + x.

The x is not multiplied by anything because the next x index is right after the previous one.

If you want to skip one Y row, you have to add whole row WIDTH, in this case 2, for example if you are at index 1, which has z=0,y=0 and x=1 and you add WIDTH=2 to index, you'll get index 3. Only y dimension has increased by 1.

To move from z=0 to z=1, you have to skip 4 indexes (look up at the index listing), the number is HEIGHT*WIDTH (in this example 2*2).

Performance

To gain speed its best to process your 3D data with z,y,x coordinates incrementing in a sequence so you don't have to recalculate the index so often. For example:

int z = 1, y=1, x=0;
int index = HEIGHT*WIDTH*z + WIDTH*y;
int data;

for(x=0;x<WIDTH;x++)
{
    Object obj = oneDArray[index+x];
}

In ideal case, all processing of data is independent from each other and you don't have to even calculate the index, just increment one index trough whole oneDArray. What's possible to precompute depends on your usage.

One approach -

def inside3d(input):
    # Get idx in 3D
    idx3d = np.floor(input).astype(np.int)

    # Create a similar mask as witrh 2D case, but in 3D now
    mask3d = grid[idx3d[:,:,0], idx3d[:,:,1]]==1

    # Count of mask matches for each index in 0th dim    
    counts = np.sum(mask3d,axis=1)

    # Index into input to get masked matches across all elements in 0th dim
    out_cat_array = input.reshape(-1,2)[mask3d.ravel()]

    # Split the rows based on the counts, as the final output
    return np.split(out_cat_array,counts.cumsum()[:-1])

Verify results -

Create 3D random input:

In [91]: random_pts3d = np.random.random(size=(3, 100, 2)) * len(grid)

With inside3d:

In [92]: inside3d(random_pts3d)
Out[92]: 
[array([[ 10.71196268,  12.9875877 ],
        [ 10.29700184,  10.00506662],
        [ 13.80111411,  14.80514828],
        [ 12.55070282,  14.63155383]]), array([[ 10.42636137,  12.45736944],
        [ 11.26682474,  13.01632751],
        [ 13.23550598,  10.99431284],
        [ 14.86871413,  14.19079225],
        [ 10.61103434,  14.95970597]]), array([[ 13.67395756,  10.17229061],
        [ 10.01518846,  14.95480515],
        [ 12.18167251,  12.62880968],
        [ 11.27861513,  14.45609646],
        [ 10.895685  ,  13.35214678],
        [ 13.42690335,  13.67224414]])]

With inside:

In [93]: inside(random_pts3d[0])
Out[93]: 
array([[ 10.71196268,  12.9875877 ],
       [ 10.29700184,  10.00506662],
       [ 13.80111411,  14.80514828],
       [ 12.55070282,  14.63155383]])

In [94]: inside(random_pts3d[1])
Out[94]: 
array([[ 10.42636137,  12.45736944],
       [ 11.26682474,  13.01632751],
       [ 13.23550598,  10.99431284],
       [ 14.86871413,  14.19079225],
       [ 10.61103434,  14.95970597]])

In [95]: inside(random_pts3d[2])
Out[95]: 
array([[ 13.67395756,  10.17229061],
       [ 10.01518846,  14.95480515],
       [ 12.18167251,  12.62880968],
       [ 11.27861513,  14.45609646],
       [ 10.895685  ,  13.35214678],
       [ 13.42690335,  13.67224414]])