Python - Find similar colors, best way

Question

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.

You should return something if you don't find the color in the image. ie, an error code. — jb., Jan 14 '12 at 17:17
How are you defining the tolerance? Separate ranges for `r`, `g` and `b`? — Ricardo Cárdenes, Jan 14 '12 at 17:17
I'm with John: what have you already tried? You might look at [cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity) and search for Python implementations. — Kurt McKee, Jan 14 '12 at 17:20
@jb.: returning None is Pythonic, and that's what his code already does. — John Zwinck, Jan 14 '12 at 17:26

score 22 · Accepted Answer · edited May 23 '17 at 12:25

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/

See my answer for an optimized `Python` version. – Developer Dec 31 '12 at 05:04 — Developer, Dec 31 '12 at 05:04

score 5 · Answer 2 · answered Dec 31 '12 at 05:03

5

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

answered Dec 31 '12 at 05:03

Developer

7,104
7
43
53

From what I've seen, `x**0.5` is much slower than `from math import sqrt`, then use `sqrt(x)`. But if you `import math` and use `math.sqrt(x)` you will see little to no difference. – JHolta Aug 08 '13 at 06:29
2

`(35,255,24)` vs `(38,38,120)` returns `nan` – Marcel Wilson Jul 31 '17 at 17:52
3

This doesn't work at all and I just wasted 30 minutes debugging it – Akababa Oct 12 '19 at 03:13

score 2 · Answer 3 · answered Jun 09 '19 at 13:58

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

score 2 · Answer 4 · answered Jan 14 '12 at 17:25

2

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

answered Jan 14 '12 at 17:25

Aloo Gobi

176
1
3

John Zwinck · Answer 5 · 2012-01-14T18:10:51.993

2

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.

edited Jan 14 '12 at 18:10

answered Jan 14 '12 at 17:26

John Zwinck

207,363
31
261
371

@SLACKY, you'd need to `import operator` first. (This being said, this is still a formula for Euclidian distance: this will not give you the results you expect visually.) – Bruno Jan 14 '12 at 17:43
@Bruno: my metric is even worse than the Euclidean distance! I didn't put any emphasis on that part (but upvoted your answer for doing so). If the tolerance is small it may not matter, but if the tolerance is large it probably will matter. – John Zwinck Jan 14 '12 at 17:45
@JohnZwinch: ah yes, sorry, I misread the formula (no squares...). It looks like a [Chebyshev distance](http://en.wikipedia.org/wiki/Chebyshev_distance). – Bruno Jan 14 '12 at 17:51
Oops--Python abs only does one item at a time. I've updated my answer to use a lambda to do the subtraction and abs on each element. – John Zwinck Jan 14 '12 at 18:08

Manish S · Answer 6 · 2020-07-01T11:43:02.543

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)

score 0 · Answer 7 · answered Mar 04 '17 at 19:31

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.

score 0 · Answer 8 · answered Jan 14 '12 at 17:17

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

score -1 · Answer 9 · answered May 26 '19 at 22:21

-1

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

answered May 26 '19 at 22:21

B. Branchard

408
5
18

Gives wrong answer. My whole project was about to be ruined because of this – Black Thunder Oct 07 '19 at 05:03

Python - Find similar colors, best way

9 Answers9

Linked