Develop Reference

Combining 3 channel numpy array to form an rgb image

I was trying to combine 3 gray scale images into a single overlapping image with three different colors for each.
For that, I added each into a 3 channel numpy array.
But when plotting with im.show I don't get a colourful image. Till adding 2nd channel it works, but when I add the third channel, it doesn't work. The final image has only red and blue colour.
It is supposed to be red, green and blue for corresponding to the overlapping images.
Why would it be?
image1 = Image.open("E:/imaging/04102022_Bronze/Copper_4_2/10.tif") #openingimage1
image1_norm =(np.array(image1)-np.array(image1).min() ) / (np.array(image1).max() -
np.array(image1).min()) #normalisingimage1
image2 = Image.open("E:/imaging/04102022_Bronze/Oxygen_1_2/10.tif")#openingimage2
image2_norm = (np.array(image2)-np.array(image2).min()) / (np.array(image2).max() -
np.array(image2).min())#normalisingimage2
image3 = Image.open("E:/imaging/04102022_Bronze/Oxygen_1_2/10.tif")#openingimage3
image3_norm = (np.array(image3)-np.array(image3).min()) / (np.array(image3).max() -
np.array(image3).min())#normalisingimage3
im=np.array(image2)
new_image = np.zeros(im.shape + (3,)) #creating an empty 3 channel numpy array .shape of this
array is (255, 1024, 3)
new_image[:,:,0] = image1_norm #adding the three images into three channels
new_image[:,:,1] = image2_norm
new_image[:,:,2] = image3_norm
new_image1=new_image*255.999
new_image2= new_image1.astype(np.uint8)
final_image=final_image=Image.fromarray(new_image2, mode='RGB')

A few possible issues...
When you open an image in PIL, if you want to be sure it is single-channel greyscale, and not accidentally 3-channel RGB, or a palette image, force it to greyscale:
im = Image.open('image.png').convert('L')
Try not to repeat complicated calculations or expressions several times - it just makes for a maintenance nightmare. Maybe use a function instead:
def normalize(im):
# Normalise image to range 0..1
min, max = im.min(), im.max()
return (im.astype(float)-min)/(max-min)
You can use Numpy's dstack() to merge channels - it means "depth"-stack, as opposed to np.vstack() which stacks images vertically above/below each other and np.hstack() which stacks images side-by-side horizontally. It is a lot simpler than creating an image of the right size and individually pushing each channel into it.
result = np.dstack((im1, im2, im3))
That would make the overall code more like this:
#!/usr/bin/env python3
from PIL import Image
import numpy as np
def normalize(im):
# Normalise image to range 0..1
min, max = im.min(), im.max()
return (im.astype(float)-min)/(max-min)
# Load images as single channel Numpy arrays
im1 = np.array(Image.open('ch1.png').convert('L'))
im2 = np.array(Image.open('ch2.png').convert('L'))
im3 = np.array(Image.open('ch3.png').convert('L'))
# Normalize and scale
n1 = normalize(im1) * 255.999
n2 = normalize(im2) * 255.999
n3 = normalize(im3) * 255.999
# Merge channels to RGB
result = np.dstack((n1,n2,n3))
result = Image.fromarray(result.astype(np.uint8))
result.save('result.png')
That makes these three input images:
into this merged image:

Using python to fill an image with one color in steps from 0% to 100%

I have a black image that I need to fill with a new color.
I want to generate new images starting from 1% to 100% (generating an
image for every 1% filled).
Examples for 4 fill-ratios
Heart image filled with 1%, 5%, 10% and 15%
Research I did
I did a lot of research on the internet and the closest I came was this link:
Fill an image with color but keep the alpha (Color overlay in PIL)
However, as I don't have much experience with Python for image editing, I couldn't move forward or modify the code as needed.
Edit:
I was trying with this code from the link
from PIL import Image
import numpy as np
# Open image
im = Image.open('2746646.png')
# Make into Numpy array
n = np.array(im)
# Set first three channels to red
n[..., 0:3] = [ 255, 0, 0 ]
# Convert back to PIL Image and save
Image.fromarray(n).save('result.png')
But it only generates a single image (as if it were 100%, I need 100 images with 1% filled in each one).

Updated Answer
Now you have shared your actual starting image, it seems you don't really want to replace black pixels, but actually opaque pixels. If you split your image into its constituent RGBA channels and lay them out left-to-right R,G,B then A, you can see you want to fill where the alpha (rightmost) channel is white, rather than where the RGB channels are black:
That changes the code to this:
#!/usr/bin/env python3
from PIL import Image
import numpy as np
# Load image, ensure not palettised, and make into Numpy array
im = Image.open('muscle.png').convert('RGBA')
# Make Numpy array
RGBA = np.array(im)
# Get RGB part
RGB = RGBA[..., :3]
# Get greyscale version of image as Numpy array
alpha = RGBA[..., 3]
# Find X,Y coordinates of all black pixels in image
blkY, blkX = np.where(alpha==255)
# Just take one entry per row, even if multiple black pixels in it
uniqueRows = np.unique(blkY)
# How many rows are there with black pixels in?
nUniqueRows = len(uniqueRows)
for percent in range(2,101):
# Work out filename based on percentage
filename = f'result-{percent:03d}.png'
# How many rows do we need to fill?
nRows = int(nUniqueRows * percent/100.0)
# Which rows are they? Negative index because filling bottom-up.
rows = uniqueRows[-nRows:]
print(f'DEBUG: filename: {filename}, percent: {percent}, nRows: {nRows}, rows: {rows}')
# What are the indices onto blkY, blkX ?
indices = np.argwhere(np.isin(blkY, rows))
# Make those pixels black
RGB[blkY[indices.ravel()], blkX[indices.ravel()], :3] = [0,255,0]
res = Image.fromarray(RGBA).save(filename)
Original Answer
That was fun! This seems to work - though it's not that efficient. It is not a true "floodfill", see note at end.
#!/usr/bin/env python3
from PIL import Image
import numpy as np
# Load image, ensure not palettised, and make into Numpy array
im = Image.open('heart.png').convert('RGB')
# Make Numpy array
na = np.array(im)
# Get greyscale version of image as Numpy array
grey = np.array(im.convert('L'))
# Find X,Y coordinates of all black pixels in image
blkY, blkX = np.where(grey==0)
# Just take one entry per row, even if multiple black pixels in it
uniqueRows = np.unique(blkY)
# How many rows are there with black pixels in?
nUniqueRows = len(uniqueRows)
for percent in range(1,101):
# Work out filename based on percentage
filename = f'result-{percent:03d}.png'
# How many rows do we need to fill?
nRows = int(nUniqueRows * percent/100.0)
# Which rows are they? Negative index because filling bottom-up.
rows = uniqueRows[-nRows:]
# print(f'DEBUG: filename: {filename}, percent: {percent}, nRows: {nRows}, rows: {rows}')
# What are the indices onto blkY, blkX ?
indices = np.argwhere(np.isin(blkY, rows))
# Make those pixels green
na[blkY[indices.ravel()], blkX[indices.ravel()], :] = [0,255,0]
res = Image.fromarray(na).save(filename)
Note that this isn't actually a true "flood fill" - it is more naïve than that - because it doesn't seem necessary for your image. If you add another shape, it will fill that too:

Read 50 images as each pixel matrix from a pool of 1000 images

I have 1000 grayscale images with a dimension of 800x600 pixels.
Each pixel have a value beetween 0...255.
I want to pick out 50 images of this 1000 images.
Of this 50 images I want to find out the max. grayscale value (0...255).
From this I want to build only one new image with the max. grascale value (0...255).
At the end I wand to take each of the 1000 images and divide each pixel by the new image pixel and multiply with 255.
I start with chose the first 50 picked images:
from random import seed
from random import sample
# seed random number generator
seed(1)
# prepare a sequence
sequence = [i for i in range(1000)]
print(sequence)
# select a subset without replacement
subset = sample(sequence, 50)
print("Chosed 50 random images: ", subset)
Then I start to read the images in a loop.
Read out the max. pixel value from the 50 picked images:
for i in range(0,49):
for d in range(0, 599):
for s in range(0, 799):
print("Chosed image: ", subset[i], "Chosed pixel (rundownstairs): ", d, "Chosed pixel (run sidewise): ", s )
But I have not idea to read the pixels in a matrix and make the mathematical matrix calculations.

As I don't have your images, I generated n random images.
I did an array with these images and found their coordinates with max value. Then I organized those indexes so that it can be read:
With listOfCordinates you should be able to start doing operations with your pixels.
NOTE that I used numpy, I don't know if that's a problem.
import numpy as np
import cv2
import matplotlib.cm as cm
import matplotlib.pyplot as plt
import glob, os
os.chdir("C:/Users\iareval1\Documents\OCLASS\class_def") #your folder
n = 5 #Number oof images
img_arr = [] #array with images
n_nad_files = []
for i in range(0,n):
n_nad_files.append(glob.glob("*.png")[np.random.randint(n)])
for file in n_nad_files: #set the file termination
img = cv2.imread(file, 0)
img_arr.append(img)
dim_x = img_arr[0].shape[0]
dim_y = img_arr[0].shape[1]
img_with_max = np.zeros((dim_x, dim_y))
cnt = 0
for image in img_arr:
print("Max values in image " + str(cnt))
for x in range (0, dim_x):
for y in range (0, dim_y):
img_with_max[x][y] = max(img_with_max[x][y], image[x][y])
cnt += 1
If you want to plot an image you can
plt.imshow(YOUR_IMAGE,cmap=cm.bone) #show your array with the selected colour
plt.show() #show the image

For image processing I recommend you opencv, you have to install it. For reading an image in grayscale you can use this, you will get a numpy array:
import cv2
import numpy as np
img = cv2.imread('image_file_path', 0)
For finding the maximum value in an array you can use this:
max_value = np.max(img)
And for applying mathematical operations to the entire array just do something like this:
mod_img = img / max_value

Using dicom Images with OpenCV in Python

I am trying to use a dicom image and manipulate it using OpenCV in a Python environment. So far I have used the pydicom library to read the dicom(.dcm) image data and using the pixel array attribute to display the picture using OpenCV imshow method. But the output is just a blank window. Here is the snippet of code I am using at this moment.
import numpy as np
import cv2
import pydicom as dicom
ds=dicom.dcmread('sample.dcm')
cv2.imshow('sample image dicom',ds.pixel_array)
cv2.waitkey()
If i print out the array which is used here, the output is different from what i would get with a normal numpy array. I have tried using matplotlib imshow method as well and it was able to display the image with some colour distortions. Is there a way to convert the array into a legible format for OpenCV?

Faced a similar issue. Used exposure.equalize_adapthist() (source). The resulting image isn't a hundred percent to that you would see using a DICOM Viewer but it's the best I was able to get.
import numpy as np
import cv2
import pydicom as dicom
from skimage import exposure
ds=dicom.dcmread('sample.dcm')
dcm_sample=ds.pixel_array
dcm_sample=exposure.equalize_adapthist(dcm_sample)
cv2.imshow('sample image dicom',dcm_sample)
cv2.waitkey()

I have figured out a way to get the image to show. As Dan mentioned in the comments, the value of the matrix was scaled down and due to the imshow function, the output was too dark for the human eye to differentiate. So, in the end the only thing i needed to do was multiply the entire mat data with 128. The image is showing perfectly now. multiplying the matrix by 255 over exposes the picture and causes certain features to blow. Here is the revised code.
import numpy as np
import cv2
import pydicom as dicom
ds=dicom.dcmread('sample.dcm')
dcm_sample=ds.pixel_array*128
cv2.imshow('sample image dicom',dcm_sample)
cv2.waitkey()

I don't think that is a correct answer. It works for that particular image because most of your pixel values are in the lower range. Check this OpenCV: How to visualize a depth image. It is for c++ but easily adapted to Python.

This is the best way(in my opinion) to open image in opencv as a numpy array while perserving the image quality:
import numpy as np
import pydicom, os, cv2
def dicom_to_numpy(ds):
DCM_Img = ds
rows = DCM_Img.get(0x00280010).value #Get number of rows from tag (0028, 0010)
cols = DCM_Img.get(0x00280011).value #Get number of cols from tag (0028, 0011)
Instance_Number = int(DCM_Img.get(0x00200013).value) #Get actual slice instance number from tag (0020, 0013)
Window_Center = int(DCM_Img.get(0x00281050).value) #Get window center from tag (0028, 1050)
Window_Width = int(DCM_Img.get(0x00281051).value) #Get window width from tag (0028, 1051)
Window_Max = int(Window_Center + Window_Width / 2)
Window_Min = int(Window_Center - Window_Width / 2)
if (DCM_Img.get(0x00281052) is None):
Rescale_Intercept = 0
else:
Rescale_Intercept = int(DCM_Img.get(0x00281052).value)
if (DCM_Img.get(0x00281053) is None):
Rescale_Slope = 1
else:
Rescale_Slope = int(DCM_Img.get(0x00281053).value)
New_Img = np.zeros((rows, cols), np.uint8)
Pixels = DCM_Img.pixel_array
for i in range(0, rows):
for j in range(0, cols):
Pix_Val = Pixels[i][j]
Rescale_Pix_Val = Pix_Val * Rescale_Slope + Rescale_Intercept
if (Rescale_Pix_Val > Window_Max): #if intensity is greater than max window
New_Img[i][j] = 255
elif (Rescale_Pix_Val < Window_Min): #if intensity is less than min window
New_Img[i][j] = 0
else:
New_Img[i][j] = int(((Rescale_Pix_Val - Window_Min) / (Window_Max - Window_Min)) * 255) #Normalize the intensities
return New_Img
file_path = "C:/example.dcm"
image = pydicom.read_file(file_path)
image = dicom_to_numpy(image)
#show image
cv2.imshow('sample image dicom',image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Create a steganographically hidden image with Pillow

I'm trying to learn how to create a set of images like this: this. The idea is that there are two seemingly random images, but when you XOR them, you find a secret message. I want to use Python Pillow, probably along with a simple image editor like paint.net. So my question consists of a few parts:
How do I generate an image full of random black or white pixels in Pillow.
How can I ensure certain areas of my images aren't actually random, but instead identical, ensuring an XOR compare will reveal them.

The process of creating those images is really simple. Here is an example how you could do it (not the most efficient):
Create two output images of same size
Create a template of same size, where 1 (white) means foreground (the hidden message) and 0 (black) means background (purely random).
Iterate over both images and the template in one loop:
If the template at current position says 0, draw two random numbers (zero or one) and assign them to the current pixel of each output image
If the template says 1, draw only one random number and assign it to both pixels
I will not go into detail on how you read your template image, create binary output images and iterate over them using Pillow, as I never tried Pillow. Drawing random numbers however is very simple:
x = random.randint(0,1) (see https://docs.python.org/2/library/random.html#random.randint)

To get you started, here's a way to make random binary images:
from PIL import Image
import numpy as np
# Make lots of ones and zeros.
data = np.random.randint(2, size=(100,100))
# Cast as 8-bit ints, 0 and 255.
data = data.astype(np.uint8) * 255
# Cast as an image. Pillow guesses mode.
img = Image.fromarray(data)
Result (magnified to 300 × 300 pixels):

For future posterity, here's what I did:
First I made a mask image. It was a white background with a red box and black text in the box. Looks like this:
Here's the script I wrote to make the two fuzzy images:
from PIL import Image
import random
WHITE = (255, 255, 255, 255)
RED = (255, 0, 0, 255)
BLACK = (0, 0, 0, 255)
wb = [WHITE,BLACK]
rng = random.SystemRandom()
orig = Image.open('mask.png')
origData = list(orig.getdata())
n1 = Image.new(orig.mode, orig.size)
n2 = Image.new(orig.mode, orig.size)
n1data = []
n2data = []
for x in origData:
if x == WHITE:
n1data.append(rng.choice(wb))
n2data.append(rng.choice(wb))
elif x == RED:
y = bool(rng.getrandbits(1))
if y:
n1data.append(WHITE)
n2data.append(BLACK)
else:
n1data.append(BLACK)
n2data.append(WHITE)
elif x == BLACK:
y = bool(rng.getrandbits(1))
if y:
n1data.append(WHITE)
n2data.append(WHITE)
else:
n1data.append(BLACK)
n2data.append(BLACK)
n1.putdata(n1data)
n2.putdata(n2data)
n1.save('n1.png')
n2.save('n2.png')
orig.close()
n1.close()
n2.close()
Resulted in these:
XOR them together and you get this: