CODEWITHSUNDEEP
pythonarraysopencvnumpy
Marciano
Marciano

Reputation: 73

Copy numpy array from one (2-D) to another (3-D)

I tried to copy one array, says A (2-D) to another array, says B (3-D) which have following shape

A is m * n array and B is m * n * p array

I tried the following code but it is very slow, like 1 sec/frame

for r in range (0, h):
    for c in range (0, w):
        x = random.randint(0, 20)
        B[r, c, x] = A[r, c]

I also read some websites about fancy indexing but I still don't know how to apply it in mine.

Upvotes: 2

Views: 125

Answers (2)

hpaulj
hpaulj

Reputation: 231385

I propose a solution using array indices. M,N,P are each (m,n) index arrays, specifying the m*n elements of B that will receive data from A.

def indexing(A, p):
    m,n = A.shape
    B = np.zeros((m,n,p), dtype=int)
    P = np.random.randint(0, p, (m,n))
    M, N = np.indices(A.shape)
    B[M,N,P] = A
    return B

For comparision, the original loop, and the solution using shuffle

def looping(A, p):
    m, n = A.shape
    B = np.zeros((m,n,p), dtype=int)
    for r in range (m):
        for c in range (n):
            x = np.random.randint(0, p)
            B[r, c, x] = A[r, c]
    return B

def shuffling(A, p):
    m, n = A.shape
    B = np.zeros((m,n,p), dtype=int)
    B[:,:,0] = A
    map(np.random.shuffle, B.reshape(m*n,p))
    return B

for m,n,p = 1000,1000,20, timings are:

looping:    1.16 s
shuffling: 10 s
indexing:     271 ms

for small m,n, looping is fastest. My indexing solution takes more time to setup, but the actual assignment is fast. The shuffling solution has as many iterations as the original.

The M,N arrays don't have to be full. They can be column and row arrays, respectively

M = np.arange(m)[:,None]
N = np.arange(n)[None,:]

or 

M,N = np.ogrid[:m,:n]

This shaves off some time, more so for small test cases than a large one.

A repeatable version:

def indexing(A, p, B=None):
    m, n = A.shape
    if B is None:
        B = np.zeros((m,n,p), dtype=int)
    for r in range (m):
        for c in range (n):
            x = np.random.randint(0, p)
            B[r, c, x] = A[r, c]
    return B
indexing(A,p,indexing(A,p))

If A isn't the same size as the 1st 2 dim of B the index ranges will have to be changed. A doesn't have to be a 2D array either:

B[[0,0,2],[1,1,0],[3,4,5]] = [10,11,12]

Upvotes: 2

Lee
Lee

Reputation: 31040

Assuming that h=m, w=n and x=p, this should give you the same as you have in your example:

B[:,:,0]=A
map(np.random.shuffle, B.reshape(h*w,p))

Note also, I'm assuming the answer to NPE's question in comments is 'yes'

Upvotes: 0

Related Questions