Sample Image - maximum width is 600 pixels

Introduction

Sometimes, we have a some vague color photo that is not clear. This can be fixed. In the image processing field, it's called histogram equalization. It is important that it can expand the histogram of the image. Then, your photos will be clear.

Background

Equipment Operation System: Microsoft Windows 7 Professional (64 bit) Development Utility: Microsoft Visual Studio 2010

Using the Code

// The histogram array of the red channel.
double  aryHistogramR[256] = {0};
// The transform of histogram array of the red channel.
double  aryTransformR[256] = {0};
// The sum of pixel's gray of the red channel.
double  dobSumR = 0.0f;
// The histogram array of the red channel.
double  aryHistogramG[256] = {0};
// The transform of histogram array of the red channel.
double  aryTransformG[256] = {0};
// The sum of pixel's gray of the red channel.
double  dobSumG = 0.0f;
// The histogram array of the red channel.
double  aryHistogramB[256] = {0};
// The transform of histogram array of the red channel.
double  aryTransformB[256] = {0};
// The sum of pixel's gray of the red channel.
double  dobSumB = 0.0f;
// The temporal variables.
int     iJ   = 0;
int     iK   = 0;
// Clear the histogram.
memset ( aryHistogramR, 0x00, 256 * sizeof( double ) );
memset ( aryHistogramG, 0x00, 256 * sizeof( double ) );
memset ( aryHistogramB, 0x00, 256 * sizeof( double ) );
// The height of the image.
for ( int iY = 0; iY < imageA->DibInfo->bmiHeader.biHeight; iY++ )
{
    // The width of the image.
    for ( int iX = 0; iX < imageA->DibInfo->bmiHeader.biWidth; iX++ )
    {
        // The index is pixel position. If your bit depth is not three, you should fix it.
        // This is twenty-four bit, so there are three bytes.
        lIDXA = ( iX * 3 ) + ( iY * imageA->DibInfo->bmiHeader.biWidth * 3 );
        // Get the pixel of the blue channel.
        byteRGB_BA = imageA->DibArry[lIDXA+0];
        // Get the pixel of the green channel.
        byteRGB_GA = imageA->DibArry[lIDXA+1];
        // Get the pixel of the read channel.
        byteRGB_RA = imageA->DibArry[lIDXA+2];
        // Record gray degree to histogram.
        aryHistogramR[INT(byteRGB_RA)]++;
        aryHistogramG[INT(byteRGB_GA)]++;
        aryHistogramB[INT(byteRGB_BA)]++;
    } // The closing "the width of the image"
} // The closing "the height of the image"
// Clear the transform of histogram array
memset ( aryTransformR, 0x00, 256 * sizeof( double ) );
memset ( aryTransformG, 0x00, 256 * sizeof( double ) );
memset ( aryTransformB, 0x00, 256 * sizeof( double ) );
// The length of the histogram.
for ( iJ = 0; iJ <= 255; iJ++ )
{
    // Clear the variable of sum.
    dobSumR = 0.0f;
    dobSumG = 0.0f;
    dobSumB = 0.0f;
    // The length of the gray degree.
    for ( iK = 0; iK <= iJ; iK++ )
    {
        // The sum of gray degree.
        dobSumR = dobSumR + aryHistogramR[iK];
        dobSumG = dobSumG + aryHistogramG[iK];
        dobSumB = dobSumB + aryHistogramB[iK];
        // Transform old gray to new gray.
        // This is a rate calculate, we compute this sum, 
        // multiply 255 and then divide the image size that means divide whole pixels.
        // The results are talking us where pixel transforms.
        aryTransformR[iJ] = ( 255.0 * dobSumR / 
        	( imageA->DibInfo->bmiHeader.biWidth * imageA->DibInfo->bmiHeader.biHeight ));
        aryTransformG[iJ] = ( 255.0 * dobSumG / 
        	( imageA->DibInfo->bmiHeader.biWidth * imageA->DibInfo->bmiHeader.biHeight ));
        aryTransformB[iJ] = ( 255.0 * dobSumB / 
        	( imageA->DibInfo->bmiHeader.biWidth * imageA->DibInfo->bmiHeader.biHeight ));
    } // The closing "the length of the gray degree".
} // The closing "the length of histogram".
// The height of the image.
for ( int iY = 0; iY < imageA->DibInfo->bmiHeader.biHeight; iY++ )
{
    // The width of the image.
    for ( int iX = 0; iX < imageA->DibInfo->bmiHeader.biWidth; iX++ )
    {
        // The index is pixel position. If your bit depth is not three, you should fix it.
        // This is twenty-four bit, so there are three bytes.
        lIDXA = ( iX * 3 ) + ( iY * imageA->DibInfo->bmiHeader.biWidth * 3 );
        // Get the pixel of the blue channel.
        byteRGB_BA = imageA->DibArry[lIDXA+0];
        // Get the pixel of the green channel.
        byteRGB_GA = imageA->DibArry[lIDXA+1];
        // Get the pixel of the read channel.
        byteRGB_RA = imageA->DibArry[lIDXA+2];
        // Set the pixel transform to new pixel of the blue channel.
        imageB->DibArry[lIDXA+0] = aryTransformB[INT(byteRGB_BA)];
        // Set the pixel transform to new pixel of the green channel.
        imageB->DibArry[lIDXA+1] = aryTransformG[INT(byteRGB_GA)];
        // Set the pixel transform to new pixel of the red channel.
        imageB->DibArry[lIDXA+2] = aryTransformR[INT(byteRGB_RA)];
    } // The closing "the height of the image".
} // The closing "the width of the image".

Exception

There is a notice, if your bit depth of bitmap file is not 24 bits, you should change your bitmap files to adapt this program, or you could rewrite this source code to fit your bitmap format.
You have to install Microsoft SDK v7.1, because I include windowscodes.lib.
```
#pragma comment(lib, "windowscodecs.lib")
```

Reference

[1] Gary Bradski and Adrian Kaehler, “Learning OpenCV: Computer Vision with the OpenCV Library,” O’REILLY, September 2008, ISBN:978-0-596-51613-0

Acknowledgement

Thank you (Microsoft Visual Studio 2010, Lenna Sjööblom) very much for this great development utility and beautiful photo.

How To Make A Clear Color Image (Histogram Equalization)?