如何将项目添加到numpy数组的每个元组元素？

Question

I have a numpy array A of shape (512, 512, 4) Each element is a tuple: (r, g, b, a). It represents a 512x512 RGBA image.

I have a numpy array B of shape (512, 512, 3) Each element is a tuple: (r, g, b). It represents a similar, RGB image.

I want to fast copy all the 'a' (alpha) values from each element of A into corresponding elements in B. (basically transferring the alpha channel).

resulting B shape would be (512, 512, 4).

How can I achieve this? The algorithm is based on fast pixel manipulation technique laid out here .

Code:

## . input_image is loaded using PIL/pillow
rgb_image = input_image
print(f"Image: {rgb_image}")
rgb_image_array = np.asarray(rgb_image) # convert to numpy array
print(f"Image Array Shape: {rgb_image_array.shape}")

gray_image = rgb_image.convert("L") # convert to grayscale
print(f"Gray image: {gray_image}")
gray_image_array = np.asarray(gray_image)
print(f"Gray image shape: {gray_image_array.shape}")

out_image_array = np.zeros(rgb_image_array.shape, rgb_image_array.dtype)
print(f"Gray image array shape: {out_image_array.shape}")

rows, cols, items = out_image_array.shape

# create lookup table for each gray value to new rgb value
LUT = []
for i in range(256):
    color = gray_to_rgb(i / 256.0, positions, colors)
    LUT.append(color)

LUT = np.array(LUT, dtype=np.uint8)

print(f"LUT shape: {LUT.shape}")

# get final output that uses lookup table technique.
# notice that at this point, we don't have the alpha channel
out_image_array = LUT[gray_image_array]
print(f"output image shape: {out_image_array.shape}")

# How do I get the alpha channel back from rgb_image_array into out_image_array

Output:

Image: <PIL.Image.Image image mode=RGBA size=512x512 at 0x7FDEF5F2F438>
Image Array Shape: (512, 512, 4)
Gray image: <PIL.Image.Image image mode=L size=512x512 at 0x7FDEF5C25CF8>
Gray image shape: (512, 512)
Gray image array shape: (512, 512, 4)
LUT shape: (256, 3)
output image shape: (512, 512, 3)

Answer 1

Using numpy slices:

import numpy as np

A = [[(1,1,1,4)], [(1,1,1,5)]]
B = [[(2,2,2)], [(3,3,3)]]

# A and B are tensors of order 3
A = np.array(A)  
B = np.array(B)


print("A=")
print(A)
print("B=")
print(B)

C = np.copy(A)

# assign along all 1st and 2nd dimensions, but only the first three elements of the third dimension
C[:,:,0:3] = B

print("C=")
print(C)

Output:

A=
[[[1 1 1 4]]

 [[1 1 1 5]]]
B=
[[[2 2 2]]

 [[3 3 3]]]
C=
[[[2 2 2 4]]

 [[3 3 3 5]]]

Answer 2

Let's be careful about terminology

I have a numpy array A of shape (512, 512, 4) Each element is a tuple: (r, g, b, a). It represents a 512x512 RGBA image.

If A has that shape, and has a numeric dtype (eg np.int32 ), then it has 512*512*4 elements. The only way it can have a tuple element is if the dtype was object. I suspect rather that you have a 512x512 image where each pixel is represented by 4 values.

A[0,0,:]

will be a (4,) shape array representing those 4 values (sometimes called channels) of one pixel.

A[:,:,0]

is the r value for the whole image.

If they really are 3d arrays, then @mocav's solution of copying columns (indexing on the last dimension) to a new array is the right one.

Another possibility is that they are structured 2d arrays with 4 and 3 fields respectively. That would print ( str ) as tuples, though the repr print will make the compound dtype explicit. But the solution will be similar - make a new array of the right shape and dtype (like A ), and copy values by field name from B and A . (I'll wait with details until you clarify the situation).