0

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.

Improve this question
1
  • What I think could be a solution is subtracting the rgb value from array, square each one, then average across and select the lowest value. Not sure how it compares to fmw42's answer. Commented Jul 28, 2020 at 23:09

3 Answers 3

Reset to default
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
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

I get the following error: r = retina[:,:,:,0] IndexError: too many indices for array As well, did you mean to write (r-0)**2 and (g-0)**2 above? I also want the minimum coordinates (min1_d) and the second lowest coordinates (min2_d), not either or
@2567655222 r-0=r, g-0=g, there is one axis too many in each retina[:,:,:,0], should be retina[:,:,0]. One thing to note is that if your original array is type uint8 the result will be incorrect, as was when I tested it. Speed wise this implementation is almost twice as fast as mine(0.059s/op vs 0.035s/op) as it does not average all of the rgb values.
0

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:

enter image description here

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):

enter image description here

Thresholded rmse image:

enter image description here

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

Improve this answer

Comments

0

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.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.