CODEWITHSUNDEEP
pythoncolorsfind
b0bz
b0bz

Reputation: 2200

Python - Find similar colors, best way

I've made a function to find a color within a image, and return x, y. Now I need to add a new function, where I can find a color with a given tolerence. Should be easy?

Code to find color in image, and return x, y:

def FindColorIn(r,g,b, xmin, xmax, ymin, ymax):
    image = ImageGrab.grab()
    for x in range(xmin, xmax):
        for y in range(ymin,ymax):
            px = image.getpixel((x, y))
            if px[0] == r and px[1] == g and px[2] == b:
                return x, y

def FindColor(r,g,b):
    image = ImageGrab.grab()
    size = image.size
    pos = FindColorIn(r,g,b, 1, size[0], 1, size[1])
    return pos

Outcome:

Taken from the answers the normal methods of comparing two colors are in Euclidean distance, or Chebyshev distance.

I decided to mostly use (squared) euclidean distance, and multiple different color-spaces. LAB, deltaE (LCH), XYZ, HSL, and RGB. In my code, most color-spaces use squared euclidean distance to compute the difference.

For example with LAB, RGB and XYZ a simple squared euc. distance does the trick:

if ((X-X1)^2 + (Y-Y1)^2 + (Z-Z1)^2) <= (Tol^2) then
  ...

LCH, and HSL is a little more complicated as both have a cylindrical hue, but some piece of math solves that, then it's on to using squared eucl. here as well.

In most these cases I've added "separate parameters" for tolerance for each channel (using 1 global tolerance, and alternative "modifiers" HueTol := Tolerance * hueMod or LightTol := Tolerance * LightMod).

It seems like colorspaces built on top of XYZ (LAB, LCH) does perform best in many of my scenarios. Tho HSL yields very good results in some cases, and it's much cheaper to convert to from RGB, RGB is also great tho, and fills most of my needs.

Upvotes: 23

Views: 27378

Answers (10)

duesterdust
duesterdust

Reputation: 87

I compared the Euclidean approach with the perceived color approach posted by Bruno for 512 different colors. The results are normalized, so 1 means maximum difference and 0 means same color. Here you can see both values plotted against each other: Euclidean vs. perceived color distance (normalized)

As you can see, the Euklidean distance does not derive extemely much from the perceived color distance. Here's the code to get the values in Python:

def get_perceived_color_distance_unnormalized(color1, color2):
    r1, g1, b1 = color1
    r2, g2, b2 = color2

    r = r1 - r2
    g = g1 - g2
    b = b1 - b2
    r_mean = (r1 + r2) / 2

    return math.sqrt(
        (512 + r_mean) / 256 * r ** 2 # >> 8 is same as dividing by 256
      + 4 * g ** 2
      + (767 - r_mean) / 256 * b ** 2)

def get_euclidean_color_distance_unnormalized(color1, color2):
    r1, g1, b1 = color1
    r2, g2, b2 = color2

    return math.sqrt(
        (r1 - r2) ** 2
      + (g1 - g2) ** 2
      + (b1 - b2) ** 2)

Black = (0, 0, 0)
White = (255, 255, 255)

maximum_perceived_distance = get_perceived_color_distance_unnormalized(White, Black)
maximum_euclidean_distance = get_euclidean_color_distance_unnormalized(White, Black)

def get_perceived_color_distance(color1, color2):
    """ Calculates a normalized distance (from 0 to 1) between two colors meaningful to the eyes (https://www.compuphase.com/cmetric.htm). """
    return get_perceived_color_distance_unnormalized(color1, color2) / maximum_perceived_distance

def get_euclidean_color_distance(color1, color2):
    """ Calculates a normalized Euclidean distance (from 0 to 1) between two colors. """
    return get_euclidean_color_distance_unnormalized(color1, color2) / maximum_euclidean_distance

Upvotes: 0

Manish S
Manish S

Reputation: 799

A cleaner python implementation of the function stated here, the function takes 2 image paths, reads them using cv.imread and the outputs a matrix with each matrix cell having difference of colors. you can change it to just match 2 colors easily

        import numpy as np
        import cv2 as cv    
        
        def col_diff(img1, img2):
            img_bgr1 = cv.imread(img1) # since opencv reads as B, G, R
            img_bgr2 = cv.imread(img2)
            r_m = 0.5 * (img_bgr1[:, :, 2] + img_bgr2[:, :, 2])
            delta_rgb = np.square(img_bgr1- img_bgr2)
            cols_diffs = delta_rgb[:, :, 2] * (2 + r_m / 256) + delta_rgb[:, :, 1] * (4) + 
                            delta_rgb[:, :, 0] * (2 + (255 - r_m) / 256)
            cols_diffs = np.sqrt(cols_diffs)            
            # lets normalized the values to range [0 , 1] 
            cols_diffs_min = np.min(cols_diffs)
            cols_diffs_max = np.max(cols_diffs)
            cols_diffs_normalized = (cols_diffs - cols_diffs_min) / (cols_diffs_max - cols_diffs_min)
            
            return np.sqrt(cols_diffs_normalized)

Upvotes: 1

Lumos
Lumos

Reputation: 357

Here's a vectorised Python (numpy) version of Bruno and Developer's answers (i.e. an implementation of the approximation derived here) that accepts a pair of numpy arrays of shape (x, 3) where individual rows are in [R, G, B] order and individual colour values ∈[0, 1].

You can reduce it two a two-liner at the expense of readability. I'm not entirely sure whether it's the most optimised version possible, but it should be good enough.

def colour_dist(fst, snd):
    rm = 0.5 * (fst[:, 0] + snd[:, 0])
    drgb = (fst - snd) ** 2
    t = np.array([2 + rm, 4 + 0 * rm, 3 - rm]).T
    return np.sqrt(np.sum(t * drgb, 1))

It was evaluated against Developer's per-element version above, and produces the same results (save for floating precision errors in two cases out of one thousand).

Upvotes: 1

B. Branchard
B. Branchard

Reputation: 855

Here is a simple function that does not require any libraries:

def color_distance(rgb1, rgb2):
    rm = 0.5 * (rgb1[0] + rgb2[0])
    rd = ((2 + rm) * (rgb1[0] - rgb2[0])) ** 2
    gd = (4 * (rgb1[1] - rgb2[1])) ** 2
    bd = ((3 - rm) * (rgb1[2] - rgb2[2])) ** 2
    return (rd + gd + bd) ** 0.5

assuming that rgb1 and rgb2 are RBG tuples

Upvotes: -1

Bahaa Zahika
Bahaa Zahika

Reputation: 117

from pyautogui source code

def pixelMatchesColor(x, y, expectedRGBColor, tolerance=0):
r, g, b = screenshot().getpixel((x, y))
exR, exG, exB = expectedRGBColor

return (abs(r - exR) <= tolerance) and (abs(g - exG) <= tolerance) and (abs(b - exB) <= tolerance)

you just need a little fix and you're ready to go.

Upvotes: 1

Developer
Developer

Reputation: 8400

Here is an optimized Python version adapted from Bruno's asnwer:

def ColorDistance(rgb1,rgb2):
    '''d = {} distance between two colors(3)'''
    rm = 0.5*(rgb1[0]+rgb2[0])
    d = sum((2+rm,4,3-rm)*(rgb1-rgb2)**2)**0.5
    return d

usage:

>>> import numpy
>>> rgb1 = numpy.array([1,1,0])
>>> rgb2 = numpy.array([0,0,0])
>>> ColorDistance(rgb1,rgb2)
2.5495097567963922

Upvotes: 6

John Zwinck
John Zwinck

Reputation: 249592

Instead of this:

if px[0] == r and px[1] == g and px[2] == b:

Try this:

if max(map(lambda a,b: abs(a-b), px, (r,g,b))) < tolerance:

Where tolerance is the maximum difference you're willing to accept in any of the color channels.

What it does is to subtract each channel from your target values, take the absolute values, then the max of those.

Upvotes: 3

Bruno
Bruno

Reputation: 122749

Computing distances between RGB colours, in a way that's meaningful to the eye, isn't as easy a just taking the Euclidian distance between the two RGB vectors.

There is an interesting article about this here: http://www.compuphase.com/cmetric.htm

The example implementation in C is this:

typedef struct {
   unsigned char r, g, b;
} RGB;

double ColourDistance(RGB e1, RGB e2)
{
  long rmean = ( (long)e1.r + (long)e2.r ) / 2;
  long r = (long)e1.r - (long)e2.r;
  long g = (long)e1.g - (long)e2.g;
  long b = (long)e1.b - (long)e2.b;
  return sqrt((((512+rmean)*r*r)>>8) + 4*g*g + (((767-rmean)*b*b)>>8));
}

It shouldn't be too difficult to port to Python.

EDIT:

Alternatively, as suggested in this answer, you could use HLS and HSV. The colorsys module seems to have functions to make the conversion from RGB. Its documentation also links to these pages, which are worth reading to understand why RGB Euclidian distance doesn't really work:

EDIT 2:

According to this answer, this library should be useful: http://code.google.com/p/python-colormath/

Upvotes: 26

Aloo Gobi
Aloo Gobi

Reputation: 176

Assuming that rtol, gtol, and btol are the tolerances for r,g, and b respectively, why not do:

if abs(px[0]- r) <= rtol and \
   abs(px[1]- g) <= gtol and \
   abs(px[2]- b) <= btol:
    return x, y

Upvotes: 2

Michał Kwiatkowski
Michał Kwiatkowski

Reputation: 9774

Simple:

def eq_with_tolerance(a, b, t):
    return a-t <= b <= a+t

def FindColorIn(r,g,b, xmin, xmax, ymin, ymax, tolerance=0):
    image = ImageGrab.grab()
    for x in range(xmin, xmax):
        for y in range(ymin,ymax):
            px = image.getpixel((x, y))
            if eq_with_tolerance(r, px[0], tolerance) and eq_with_tolerance(g, px[1], tolerance) and eq_with_tolerance(b, px[2], tolerance):
                return x, y

Upvotes: 0

Related Questions