Gray level mapping

Histogram:

In a typical 8-bit image, there are $L=2^8=256$ discrete gray scale levels from 0 to $2^8-1=255=L-1$. The histogram of an image represents the probability density function (pdf) of the pixel values in the image over the entire gray scale range. The ith entry of the histogram is

$$h[i]=\frac{n_i}{M\,N},\;\;\;\;\;\;\;(i=0,\cdots,L-1)$$ (1)

where $n_i$ is the number of pixels of gray level $i$ in an image of size $M\times N$. $h[l]$ is an estimate of the probability for a randomly chosen pixel to take the gray level $i$. Given $h[i]$, we can further get the cumulative distribution function:

$$H[j]=\sum_{i=0}^j h[i],\;\;\;\;\;\;\;(j=0,\cdots,L-1)$$ (2)

We obviously have

$$H[L-1]=\sum_{i=0}^{L-1} h[i]=\frac{1}{MN}\sum_{i=0}^{L-1}n_i=1$$ (3)

Both the density and cumulative distribution functions $h$ and $H$ can be displayed graphically as an image.

Gray level mapping:

The appearance (brightness, contrast, etc.) of an image represented by its histogram can be modified by a user specified gray level mapping function $y=f(x)$ where $x=x[m,n]$ is a pixel in the input image and $y=y[m,n]$ is the corresponding pixel in the output image. This mapping function can be specified in different ways, such as a piecewise linear function, or based on the histogram of either or both of the input and output images.

Programming issues:

The above mapping functions can be carried out for each pixel in the image. However, this is not an efficient way computationally. A more effieicnt way to carry out this gray scale mapping is to u= use a lookup table, which stores the pre-computed mapping for each of the $L$ gray levels. The gray level of a pixel in the input image is used as the address to the table and the content of the table entry is the gray level of the corresponding pixel of the output image. Based on the lookup table, the mapping function only needs to be carried out $L$ times, instead of $M\times N$ ($>> L$) times (size of the image).

Common mapping functions:

Here are some common gray scale mapping functions $y=f(x)$:

• Thresholding:

  

  As a special case of piecewise linear mapping, thresholding is a simple way to do image segmentation, in particular, when the histogram of the image is bimodal with two peaks separated by a valley, typically corresponding to some object in the image and the background. A thresholding mapping maps all pixel values below a specified threshold to zero and all above to 255.

  

• Negative image:

  $$y=f(x)=255-x$$ (4)

  This mapping is shown below which generates the negative of the input image:

  

• Min-max linear stretch:

  

  $$y=f(x)=\left\{ \begin{array}{ll} 0 & x<min \\ \frac{x-min}{max-min} 255 & min \le x \le max \\ 255 & x>max \end{array} \right.$$ (5)

  This is a piecewise linear mapping between the input and output images of three linear segments with slopes 0 for $x<min$, $255/(max-min)>1$ for $min \le x \le max$, and 0 for $x>max$. The greater than 1 slope in the middle range stretches the dynamic range of the image to use all gray levels available in the display.

  

• Linear stretch based on histogram:

  If in the image there are only a small number of pixels close to minimum gray level 0 and the maximum gray level $L-1=255$, and the gray level of most of the pixels are concentrated in the middle range (gray) of the histogram, the above linear stretch method based on the minimum and maximum gray levels has very limited effect (as the slope $(L-1)/(max-min)$ is very close to 1).

  In this case we can push a small percentage (e.g., $3\%$, $5\%$) of gray levels at either of the two ends of the histogram toward 0 and $L-1$, as shown in the figure below. (Note that the histograms of the input and output images in the figure below are not to scale.)

  

  

• Piecewise linear mapping:

  A mapping function can be specified by a set of $n$ break-points $(x_i,y_j), i=1,2,\cdots,n$, with neighboring points connected by straight lines, such as shown here:

  

  For example, to increase the contrast of the image of Paolina, we can linearly stretch the gray scales of the image so that the darkest and brightest gray levels are mapped to 0 and 255, respectively.

Code Segments:

• Histogram:

  Here $h[i]$ and $H[i]$ are the density and cumulative distribution functions.

      for (i=0; i<L; i++) {
          h[i]=0; H[i]=0;
      }
      v=1.0/M/N;
      for (i=0; i<M; i++)
          for (j=0; j<N; j++)
              h[x[i][j]]=h[x[i][j]]+v;
      H[0]=h[0];
      for (i=1; i<L; i++)
          H[i]=H[i-1]+h[i];
  

• Find cut-off levels:

  Assume $cut\_low$ and $cut\_high$ are fractions such as $3\%=0.03$ or $5\%=0.05$.

          w=0; min=0;
          while (w < cut_low)
              w+=h[min++];
          w=0; max=L-1;
          while (w < cut_high)
              w+=h[max--];
  

• Build lookup table:

          slope=(L-1)/(max-min);
          for (i=0; i<L;  i++)
              if (i < min) lookup[i]=0;
              else if (i >= max) lookup[i]=L-1;
              else lookup[i]=slope*(i-min);
  

• Obtain output:

          for (i=0; i<M; i++)
              for (j=0; j<N; j++)
                  y[i][j]=lookup[x[i][j]];