Graphics code snippet to perform a histogram equalization on a VCL TImage.

DoHistogramEqualization is similar to EnhanceContrast, except that EnhanceContrast is 'milder': it tries to minimally change the average greyness (using GetAverageGreyness to first measure it).

I have also programmed a tool that uses DoHistogramEqualization, called HistogramEqualizationer.

DoHistogramEqualization works on both grey and color images.

DoHistogramEqualization assumes you have defined the functions GetImageHistogram and GetCumulativeHistogram.

* View an example of a composition image demonstrating DoHistogramEqualization: first, on the original (top) image, a ConvertToGrey was performed, resulting in the middle image. On this result, DoHistogramEqualization was performed on, resulting in the bottom image.

* View an example of a composition image demonstrating EnhanceContrast and DoHistogramEqualization: first, on the original (top-left) image, a DoFilterOperation was performed, resulting in the bottom-left image. On this result, both a DoHistogramEqualization (top-right) and EnhanceContrast (bottom-right) were performed on.

* View the code of 'DoHistogramEqualization' in plain text

* Go to the page of 'HistogramEqualizationer'

//From http://www.richelbilderbeek.nl/CppDoHistogramEqualization.htm

void DoHistogramEqualization(const TImage * const source, TImage * const target)

{

assert(source!=0 && "Source image is NULL");

assert(target!=0 && "Target image is NULL");

assert(source->Picture->Bitmap!=0 && "Source bitmap is NULL");

assert(target->Picture->Bitmap!=0 && "Target bitmap is NULL");

assert(source->Picture->Bitmap->PixelFormat == pf24bit && "Source bitmap must be 24 bit");

assert(target->Picture->Bitmap->PixelFormat == pf24bit && "Target bitmap must be 24 bit");

//Get the width and height from the source

const int width = source->Picture->Bitmap->Width;

const int height = source->Picture->Bitmap->Height;

//Set the target's width and height

target->Picture->Bitmap->Width = width;

target->Picture->Bitmap->Height = height;

const int surface = width * height;

const int nGreyValues = 256; //There are 256 different pixel intensities

const std::vector<int> histogram = GetImageHistogram(source);

assert(nGreyValues==static_cast<int>(histogram.size()));

const std::vector<int> cumulativeHistogram = GetCumulativeHistogram(histogram);

assert(nGreyValues==static_cast<int>(cumulativeHistogram.size()));

//Works, but anybody knows how to use std::for_each or std::transform for this?

std::vector<int> rescaledHistogram(nGreyValues,0);

for (int i=0; i!=nGreyValues; ++i)

{

//'surface + 1' to prevent that rescaledGreyValue == 256

const int rescaledGreyValue

= static_cast<int>(

static_cast<double>(nGreyValues)

* static_cast<double>(cumulativeHistogram[i])

/ static_cast<double>(surface + 1) );

assert(rescaledGreyValue >= 0);

assert(rescaledGreyValue < 256);

rescaledHistogram[i] = rescaledGreyValue;

}

for (int y=0; y!=height; ++y)

{

const unsigned char * lineSource

= static_cast<const unsigned char *>(

source->Picture->Bitmap->ScanLine[y]);

unsigned char * lineTarget

= static_cast<unsigned char *>(

target->Picture->Bitmap->ScanLine[y]);

for (int x=0; x!=width; ++x)

{

const int greyOriginal

= (lineSource[x*3+0] + lineSource[x*3+1] + lineSource[x*3+2]) / 3;

assert(greyOriginal >= 0);

assert(greyOriginal < 256);

const int greyNew = rescaledHistogram[greyOriginal];

assert(greyNew >= 0);

assert(greyNew < 256);

lineTarget[x*3+0]=greyNew; //Blue

lineTarget[x*3+1]=greyNew; //Green

lineTarget[x*3+2]=greyNew; //Red

}

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

(C++) DoHistogramEqualization