Making a metric between colors (perception model) with "difference"

Question

Take a look at the image below. If you're not color blind, you should see some A's and B's. There are 3 A's and 3 B's in the image, and they all have one thing in common: Their color is the background + 10% of value, saturation and hue, in that order. For most people, the center letters are very hard to see - saturation doesn't do much, it seems!

This is a bit troublesome though because I'm making some character recognition software, and I'm filtering the image based on known foreground and background colors. But sometimes these are quite close, while the image is noisy. In order to decide whether a pixel belongs to a letter or to the background, my program checks Euclidean RGB distance:

(r-fr)*(r-fr) + (g-fg)*(g-fg) + (b-fb)*(b*fb) < 
(r-br)*(r-br) + (g-bg)*(g-bg) + (b-bb)*(b*bb) 

This works okay, but for close backgrounds and foregrounds, it works pretty bad sometimes.

Are there some better metrics to look for? I've looked into color perception models but those mostly model brightness rather than perceptive difference which I'm looking for. Maybe one that models saturation as less effective, and certain hue differences also? Any pointers to some interesting metrics would be very useful.

Answer 1

As was mentioned in the comments, the answer is using a perceptual color space, but I thought I'd throw together a visual example of how the edge detection behaves in the two color spaces. (Code is at the end.) In both cases, the Sobel edge detection is performed on the 3-channel color image, and then the result is flattened to gray scale.

RGB space:

L*a*b space (image is logarithmic, as the edges on the third letters are much more significant than the edges on the first letters, which are more significant than the edges on the second letters):

OpenCV C++ code:

#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "iostream"

using namespace cv;
using namespace std;

void show(const char *name, Mat &img, int dolog=0)
{
  double minVal, maxVal;
  minMaxLoc(img, &minVal, &maxVal);
  cout << name << " " << "minVal : " << minVal << endl << "maxVal : " << maxVal << endl;

  Mat draw;
  if(dolog) {
    Mat shifted, tmp;
    add(img, minVal, shifted);
    log(shifted, tmp);
    minMaxLoc(tmp, &minVal, &maxVal);
    tmp.convertTo(draw, CV_8U, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal));
  } else {
    img.convertTo(draw, CV_8U, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal));
  }

  namedWindow(name, CV_WINDOW_AUTOSIZE);
  imshow(name, draw);
  imwrite(name, draw);
}

int main( )
{
    Mat src;
    src = imread("AAABBB.png", CV_LOAD_IMAGE_COLOR);
    namedWindow( "Original image", CV_WINDOW_AUTOSIZE );
    imshow( "Original image", src );

    Mat lab, gray;
    cvtColor(src, lab, CV_BGR2Lab);

    Mat sobel_lab, sobel_bgr;
    Sobel(lab, sobel_lab, CV_32F, 1, 0);
    Sobel(src, sobel_bgr, CV_32F, 1, 0);

    Mat bgr_sobel_lab, gray_sobel_lab;
    cvtColor(sobel_lab, bgr_sobel_lab, CV_Lab2BGR);
    show("lab->bgr edges.png", bgr_sobel_lab, 1);
    cvtColor(bgr_sobel_lab, gray_sobel_lab, CV_BGR2GRAY);

    Mat gray_sobel_bgr;
    cvtColor(sobel_bgr, gray_sobel_bgr, CV_BGR2GRAY);

    show("lab edges.png", gray_sobel_lab, 1);
    show("bgr edges.png", gray_sobel_bgr);

    waitKey(0);                                        
    return 0;
}