Improving Numpy For Loop Speed

Question

I'm trying to find the pixels closest to an RGB value of (0,0,255). I'm trying to calculate the distance of the pixel in RGB values to that value using a 3D Pythagoras calculation, add them to a list, and then return the X and Y coordinates of the values that have the lowest distance. Here's what I have:

# import the necessary packages
import numpy as np
import scipy.spatial as sp
import matplotlib.pyplot as plt
import cv2
import math
from PIL import Image, ImageDraw, ImageFont

background = Image.open("test.tif").convert('RGBA')
png = background.save("test.png")

retina = cv2.imread("test.png")
#convert BGR to RGB image
retina = cv2.cvtColor(retina, cv2.COLOR_BGR2RGB)

h,w,bpp = np.shape(retina)

min1_d = float('inf')
min1_coords = (None, None)

min2_d = float('inf')
min2_coords = (None, None)


for py in range(0,h):
    for px in range (0,w):
        r = retina[py][px][0]
        g = retina[py][px][1]
        b = retina[py][px][2]
        d = math.sqrt(((r-0)**2) + ((g-0)**2) + ((255-b)**2))
        print(str(r) + "," + str(g) + "," + str(b) + ",," + str(px) + "," + str(py) + ",," + str(d))
        if d < min1_d:
            min2_d = min1_d
            min2_coords = min1_coords
            
            min1_d = d
            min1_coords = (px, py)
        elif d < min2_d: # if it's not the smallest, check if it's the second smallest
            min2_d = d
            min2_coords = (px, py)

print(min1_coords, min2_coords)

width, height = background.size
x_max = int(width)
y_max = int(height)

img = Image.new('RGBA', (x_max, y_max), (255,255,255,0))
draw = ImageDraw.Draw(img)
draw.point(min1_coords, (0,0,255))
draw.point(min2_coords, (0,0,255))

foreground = img
background.paste(foreground, (0, 0), foreground)
foreground.save("test_bluer.png")
background.save("test_bluer_composite.png")

How can I speed up my for loops? I believe this answer is on the right track, but I'm not sure how to implement the px and py variables while slicing as this answer shows.

Answer 1

You can speed up your code by vectorizing the for loop:

    r = retina[:,:,0]
    g = retina[:,:,1]
    b = retina[:,:,2]
    d = np.sqrt(r**2 + g**2 + (255-b)**2)

You can find the coordinates of the minimum with:

    min_coords = np.unravel_index(np.argmin(d), np.shape(d))

If you want to find the second smallest distance just change the previous minimum to be a larger distance:

    d[min_coords[0],min_coords[1]] = np.inf
    min_coords = np.unravel_index(np.argmin(d), np.shape(d))
    # min_coords now has the second smallest distance

Answer 2

As commented, subtract rgb value from array, square, average(or sum) pixel rgb values, get minimum.

Here is my variant:

import numpy

rgb_value = numpy.array([17,211,51])
img = numpy.random.randint(255, size=(1000,1000,3),dtype=numpy.uint8)

img_goal = numpy.average(numpy.square(numpy.subtract(img, rgb_value)), axis=2)

result = numpy.where(img_goal == numpy.amin(img_goal))
result_list = [result[0].tolist(),result[1].tolist()]
for i in range(len(result_list[0])):
    print("RGB needed:", rgb_value)
    print("Pixel:", result_list[0][i], result_list[1][i])
    print("RGB gotten:", img[result_list[0][i]][result_list[1][i]])
    print("Distance to value:", img_goal[result_list[0][i]][result_list[1][i]])

There can be multiple results with the same values.

Answer 3

Here is one way in Python/OpenCV.

• Read the input
• Define your color (pure blue)
• Create an image of the color desired
• Compute an image representing the rmse difference
• Threshold the rmse image
• Get the coordinates of all white pixels

Input:

import cv2
import numpy as np

# read image
img = cv2.imread('red_blue2.png')

# reference color (blue)
color = (255,0,0)

# create image the size of the input, but with blue color
ref = np.full_like(img, color)

# compute rmse difference image
diff = cv2.absdiff(img, ref)
diff2 = diff*diff
b,g,r = cv2.split(diff)
rmse = np.sqrt( ( b+g+r )/3 )

# threshold for pixels within 1 graylevel different
thresh = cv2.threshold(rmse, 1, 255, cv2.THRESH_BINARY_INV)[1]

# get coordinates
coords = np.argwhere(thresh == 255)
for coord in coords:
    print(coord[1],coord[0])


# write results to disk
cv2.imwrite("red_blue2_rmse.png", (20*rmse).clip(0,255).astype(np.uint8))
cv2.imwrite("red_blue2_thresh.png", thresh)

# display it
cv2.imshow("rmse", rmse)
cv2.imshow("thresh", thresh)
cv2.waitKey(0)

RMSE Image (scaled in brightness by 20x for viewing):

Thresholded rmse image:

Coordinates:

127 0
128 0
127 1
128 1
127 2
128 2
127 3
128 3
127 4
128 4
127 5
128 5
127 6
128 6
127 7
128 7
127 8
128 8
127 9
128 9
127 10
128 10
127 11
128 11
127 12
128 12
127 13
128 13
127 14
128 14
127 15
128 15
127 16
128 16
127 17
128 17
127 18
128 18
127 19
128 19
127 20
128 20
127 21
128 21
127 22
128 22
127 23
128 23
127 24
128 24
127 25
128 25
127 26
128 26
127 27
128 27
127 28
128 28
127 29
128 29
127 30
128 30
127 31
128 31
127 32
128 32
127 33
128 33
127 34
128 34
127 35
128 35
127 36
128 36
127 37
128 37
127 38
128 38
127 39
128 39
127 40
128 40
127 41
128 41
127 42
128 42
127 43
128 43
127 44
128 44
127 45
128 45
127 46
128 46
127 47
128 47
127 48
128 48
127 49
128 49