(C++ VCL Graphics) Histogram equalization

//---------------------------------------------------------------------------
include <vector>

include <cassert>

//---------------------------------------------------------------------------
void HistogramEqualize(const TImage * const source, TImage * const target)
{
  assert(source!=0);
  assert(target!=0);
  assert(source->Width  == target->Width);
  assert(source->Height == target->Height);
  assert(source->AutoSize==true);
  assert(target->AutoSize==true);
  const int width = source->Width;
  const int height = source->Height;
  const int surface = width * height;
  const int nGreyValues = 256; //There are 256 different pixel intensities
  const std::vector<int> histogram = GetHistogram(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)
  {
    rescaledHistogram[i]
      = static_cast<double>(nGreyValues)
static_cast<double>(cumulativeHistogram[i])

      / static_cast<double>(surface);
  }
  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;
      const int greyNew = rescaledHistogram[greyOriginal];
      lineTarget[x*3+0]=greyNew; //Blue
      lineTarget[x*3+1]=greyNew; //Green
      lineTarget[x*3+2]=greyNew; //Red
    }
  }
}
//---------------------------------------------------------------------------
std::vector<int> GetHistogram(const TImage * const image)
{
  assert(image!=0);
  assert(image->AutoSize==true);
  const int width  = image->Width;
  const int height = image->Height;
  std::vector<int> histogram(256,0); //There are 256 different color intensities
  for (int y=0; y!=height; ++y)
  {
    const unsigned char * line
      = static_cast<const unsigned char *>(image->Picture->Bitmap->ScanLine[y]);
    for (int x=0; x!=width; ++x)
    {
      const int greyVal = (line[x*3+0] + line[x*3+1] + line[x*3+2]) / 3;
      assert(greyVal>=0);
      assert(greyVal<static_cast<int>(histogram.size()));
      ++(histogram[greyVal]);
    }
  }
  return histogram;
}
//---------------------------------------------------------------------------
std::vector<int> GetCumulativeHistogram(const std::vector<int>& histogram)
{
  const int size = histogram.size();
  std::vector<int> cumulativeHistogram(size,0);
  int cumulative = 0;
  for (int i=0; i!=size; ++i)
  {
    cumulative+=histogram[i];
    cumulativeHistogram[i] = cumulative;
  }
  return cumulativeHistogram;
}
//---------------------------------------------------------------------------

'Histogram equalization' links

•  ?C++
• C++ OpenCV
• General

Code links

• assert
• const