Docstoc

Grey Level and Colour Enhancement

Document Sample
Grey Level and Colour Enhancement Powered By Docstoc
					    Lecture 10
Grey Level & Colour
 Enhancement (2)

        TK3813

      Dr. Masri Ayob
                Image Histogram
The histogram of an image is a table containing
(for every gray level K) the probability of level K
actually occurring in the image
The histogram could also be viewed as a frequency
distribution of gray level within the image.
 Calculation of an image histogram:


 Create an array histogram with 2b elements
 For all grey levels, I, do
    histogram[i]=0
 End for

 For all pixel coordinates, x and y, do
    increment histogram[f(x,y)] by 1
 End for
                                                 2
Image Histogram Example




                          3
                       Image Histograms
          Dark Image

                             The histogram on the left is representative of an “under-
                             exposed” image. It has very few “bright” pixels and
                             doesn’t make good use of the full dynamic range
                             available.
    0         32        63

         Light Image

                             The histogram on the left is representative of an “over-
                             exposed” image. It has very few “dark” pixels and
                             doesn’t make good use of the full dynamic range
                             available.
    0         32        63

                              Contrast : Amount of difference between average
                              gray level of an object and that of surroundings
        Low Contrast


                             The histogram on the left is representative of an “poor
                             contrast” image. It has very few “dark” and very few
                             “light” pixels. It doesn’t make good use of the full
                             dynamic range available.                                    4
0           32         63
Image Histogram- Dark Image




                              5
                Image Histogram


Added 150 to all pixels. If sum >255 at a pixel, gray level
for that pixel is clipped to 255.




                                                         6
                     Image Histograms


                                 The histogram on the left is representative of an
                                 image with good contrast. It makes good use of the
                                 full dynamic range available.



                                Brightness span of an image’s gray scale



You can’t tell if an image is “good” just by looking
at the histogram…but the histogram may give you a
“tingly feeling” that something isn’t quite right.



                                                                                  7
                    Image Histogram




The histogram seems “uneven” but the image has good contrast. It just
happens to be a naturally “bright” image.
                                                                        8
                      Image Histogram




The histogram seems “squeezed” and it does indicate (in this case) that the
image has poor contrast.
                                                                              9
Low contrast & low dynamic range




                                   10
Higher contrast & dynamic range




                                  11
              Test Your Knowladge

Q: The image on the right was obtained by swapping the
top and bottom halves of the image on the left. What is
the relationship of the histograms of the two images?




        A: Both have the same histogram.            12
   Cumulative Distribution Function
The CDF of an image is a table containing (for
every gray level K) the probability of a pixel of level
K OR LESS actually occurring in the image

The CDF can be computed from the histogram as:

                      j
              C j   Hi
                     i 0




                                                     13
       Cumulative Distribution Function
  The CDF of represents a monotonically increasing function.
  The derivative (slope) of the CDF is steep where there are lots
  of pixels and low where there are few pixels

A function which is either entirely nonincreasing or nondecreasing. A function is
monotonic if its first derivative (which need not be continuous) does not change sign.
               Dark Image
                                               1



                                             0.8


                                             0.6



                                             0.4



                                             0.2

  0                32               63
                                                     10    20   30    40    50    60

         Image histogram                                  Image CDF
                                                                                         14
         Cumulative Distribution Function
            Low Contrast
                                           1


                                         0.8


                                         0.6


                                         0.4


                                         0.2



                                               10   20      30    40      50    60
 0                32                63                   Image CDF
             Image histogram

The CDF of an image having uniformly distributed pixel levels is
a straight-line with slope 1 (using normalized gray levels). The
derivative of the CDF is constant.
                                           1
            Good Contrast
                                         0.8


                                         0.6


                                         0.4


                                         0.2



                                               10   20       30      40    50    60
     0           32            63
                                                         Image CDF
           Image histogram                                                            15
             Histogram Processing
Histogram of a digital image with gray levels in the range
[0,L-1] is a discrete function

                      h(rk) = nk
Where
  rk : the kth gray level
  nk : the number of pixels in the image having gray level
  rk
  h(rk) : histogram of a digital image with gray levels rk




                                                             16
           Histogram Processing
Basic for numerous spatial domain processing
techniques
Used effectively for image enhancement
Information inherent in histograms also is useful in
image compression and segmentation




                                                  17
            Normalized Histogram
The probability of occurrence of gray level in an image is
approximated by
                     nk
         pr ( rk )               where k  0 , 1, ..., L-
                                                         1
                     n
The discrete version of transformation
                           k
         sk  T ( rk )   pr ( r j )
                           j 0
               k      nj
                         where k  0 , 1, ..., L-
                                                  1
               j 0   n


                                                             18
            Histogram Equalization
Thus, an output image is obtained by mapping each pixel with
level rk in the input image into a corresponding pixel with level
sk in the output image
In discrete space, it cannot be proved in general that this
discrete transformation will produce the discrete equivalent of
a uniform probability density function, which would be a
uniform histogram




                                                              19
           Histogram Equalization
As the low-contrast image’s histogram is narrow and centered
toward the middle of the gray scale, if we distribute the
histogram to a wider range the quality of the image will be
improved.
We can do it by adjusting the probability density function of
the original histogram of the image so that the probability
spread equally




                                                           20
         Histogram Equalization
Used to automatically distribute pixel values evenly
throughout the image
   each gray level should appear with identical
   probability in the image
   Often enhances an image, but not always




                                                 21
Histogram Equalization




                         22
           Histogram Equalization


E.g., consider equalizing the following 4-bit image using
the above formula:




                                                       23
          Histogram Equalization


 Before




After




                                   24
Resulting image has increased dynamic range. Resulting histogram almost,
but not completely, flat. Appears jagged and some gray levels unoccupied
since finite number of gray levels are available.
             Before                             After




                                                                       25
       Histogram Equalization Example
Source: Institue of Biotechnology, University of Helsinki, Mouse embryo 13 d pc, tissue
                               section from molar tooth




                                                                                   26
         Example

before    after    Histogram
                   equalization




                                  27
                         Example

                           No. of pixels
                             6
 2      3    3       2
                             5
 4      2    4       3       4

 3      2    3       5       3

                             2
 2      4    2       4
                             1
                                                       Gray level
     4x4 image
                                 0 1 2 3 4 5 6 7 8 9
Gray scale = [0,9]
                                           histogram
                                                           28
Gray
                     0   1       2   3     4     5    6    7    8    9
Level(j)

  No. of
                     0   0       6   5     4     1    0    0    0    0
  pixels
  k

 n
 j 0
             j       0   0       6   11    15    16   16   16   16   16


        k    nj              6      11   15   16   16   16   16   16
s                  0   0       /    /    /    /    /    /    /    /
      j 0       n
                                 16   16   16   16   16   16   16   16

                             3.3     6.1   8.4
      sx9            0   0                       9    9    9    9    9
                             3      6    8
                                                                     29
                            Example
Input       2   3   3   2
image       4   2   4   3     No. of pixels
            3   2   3   5
                                6
            2   4   2   4
                                5

                                4
        3       6   6   3
                                3
        8       3   8   6
                                2
        6       3   6   9

        3       8   3   8       1

        Output image
                                    0 1 2 3 4 5 6 7 8 9
  Gray scale = [0,9]                                    Gray level
                                      Histogram equalization 30
                            Note
It is clearly seen that
   Histogram equalization distributes the gray level to reach the
   maximum gray level (white) because the cumulative distribution
   function equals 1 when
   0  r  L-1
   If the cumulative numbers of gray levels are slightly different,
   they will be mapped to little different or same gray levels as we
   may have to approximate the processed gray level of the output
   image to integer number
   Thus the discrete transformation function can’t guarantee the
   one to one mapping relationship




                                                                  31
                      Note
Histogram processing methods are global
processing, in the sense that pixels are modified by
a transformation function based on the gray-level
content of an entire image.
Sometimes, we may need to enhance details over
small areas in an image, which is called a local
enhancement.




                                                  32
                 Local Enhancement
                                                  a)   Original image (slightly
                                                       blurred to reduce noise)
                                                  b)   global histogram
                                                       equalization (enhance
                                                       noise & slightly increase
                                                       contrast but the
                                                       construction is not
                                                       changed)
                                                  c)   local histogram
   (a)               (b)             (c)               equalization using 7x7
                                                       neighborhood (reveals
define a square or rectangular neighbourhood and       the small squares inside
move the center of this area from pixel to pixel.      larger ones of the
at each location, the histogram of the points in the   original image.
neighborhood is computed and histogram
equalization transformation function is obtained.
another approach used to reduce computation is
to utilize nonoverlapping regions, but it usually
produces an undesirable checkerboard effect.


                                                                          33
          Explain the result in c)
Basically, the original image consists of many small squares
inside the larger dark ones.
However, the small squares were too close in gray level to
the larger ones, and their sizes were too small to influence
global histogram equalization significantly.
So, when we use the local enhancement technique, it reveals
the small areas.
Note also the finer noise texture is resulted by the local
processing using relatively small neighborhoods.




                                                         34
                          Implementation

 Take a look at the built-in BuffereImageOp interface


Method Summary

 BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel destCM)
                      Creates a zeroed destination image with the correct size and number of
               bands.
 BufferedImage filter(BufferedImage src, BufferedImage dest)
                       Performs a single-input/single-output operation on a BufferedImage.

  Rectangle2D getBounds2D(BufferedImage src)
                   Returns the bounding box of the filtered destination image.
      Point2D getPoint2D(Point2D srcPt, Point2D dstPt)
                      Returns the location of the corresponding destination point given a point
               in the source image.
RenderingHints getRenderingHints()
                      Returns the rendering hints for this operation.
                                                                                             35
                          Implementation
public class StandardGreyOp implements BufferedImageOp {

    public BufferedImage filter(BufferedImage src, BufferedImage dest) {
      checkImage(src);
      if (dest == null)
        dest = createCompatibleDestImage(src, null);
      WritableRaster raster = dest.getRaster();
      src.copyData(raster);
      return dest;
    }

    public BufferedImage createCompatibleDestImage(BufferedImage src,
      ColorModel destModel) {
       if (destModel == null)
         destModel = src.getColorModel();
       int width = src.getWidth();
       int height = src.getHeight();
       BufferedImage image = new BufferedImage(destModel,
        destModel.createCompatibleWritableRaster(width, height),
        destModel.isAlphaPremultiplied(), null);
       return image;
    }

    // other methods here ///
}                                                                          36
                            Implementation
public class StandardGreyOp implements BufferedImageOp {

    // other methods here

    public Rectangle2D getBounds2D(BufferedImage src) {
      return src.getRaster().getBounds();
    }
    public Point2D getPoint2D(Point2D srcPoint, Point2D destPoint) {
      if (destPoint == null)
        destPoint = new Point2D.Float();
      destPoint.setLocation(srcPoint.getX(), srcPoint.getY());
      return destPoint;
    }
    public RenderingHints getRenderingHints() {
      return null;
    }
    public void checkImage(BufferedImage src) {
      if (src.getType() != BufferedImage.TYPE_BYTE_GRAY)
        throw new ImagingOpException("operation requires an 8-bit grey image");
    }
}




                                                                                  37
                              Implementation
public abstract class GreyMapOp extends StandardGrayOp {
  protected byte[] table = new byte[256]; // lookup table
  public abstract void computeMapping(int low, int high);

    public int getTableEntry(int i) {
      if (table[i] < 0) return 256 + (int) table[i];
      else return (int) table[i];
    }

    protected void setTableEntry(int i, int value) {
      if (value < 0) table[i] = (byte) 0;
      else if (value > 255) table[i] = (byte) 255;
      else table[i] = (byte) value;
    }

    public void computeMapping() {
      computeMapping(0, 255);
    }

    public BufferedImage filter(BufferedImage src, BufferedImage dest) {
      checkImage(src);
      if (dest == null)
        dest = createCompatibleDestImage(src, null);
      LookupOp operation = new LookupOp(new ByteLookupTable(0, table), null);
      operation.filter(src, dest);
      return dest;
    }
}



                                                                                38
                          Implementation
public class SquareRootOp extends GreyMapOp {
  public SquareRootOp() { computeMapping(); }

    public SquareRootOp(int low, int high) { computeMapping(low, high); }

    public void computeMapping(int low, int high) {
      if (low < 0 || high > 255 || low >= high)
        throw new java.awt.image.ImagingOpException("invalid mapping limits");
      double a = Math.sqrt(low);
      double b = Math.sqrt(high);
      double scaling = 255.0 / (b - a);
      for (int i = 0; i < 256; ++i) {
        int value = (int) Math.round(scaling*(Math.sqrt(i) - a));
        setTableEntry(i, value);
      }
    }
}



                                                                             39
                        Implementation
public class EqualiseOp extends GreyMapOp {
   public EqualiseOp(Histogram hist) throws HistogramException {
    float scale = 255.0f / hist.getNumSamples();
    for (int i = 0; i < 256; ++i)
      table[i] = (byte) Math.round(scale*hist.getCumulativeFrequency(i));
  }

    public void computeMapping(int low, int high) {
      // Does nothing - limits are meaningless in histogram equalisation
    }
}




                                                                            40
                           Implementation
public final class Histogram implements Cloneable {
    public Histogram();
    public Histogram(Reader reader);
    public Histogram(BufferedImage image) throws HistogramException;
    public void computeHistogram(BufferedImage image) throws HistogramException;

    private void accumulateFrequencies(BufferedImage image) throws HistogramException {
    if (image.getType() == BufferedImage.TYPE_BYTE_BINARY
        || image.getType() == BufferedImage.TYPE_USHORT_GRAY)
        throw new HistogramException("invalid image type");

    Raster raster = image.getRaster();
    if (image.getType() == BufferedImage.TYPE_BYTE_GRAY) {
        for (int y = 0; y < image.getHeight(); ++y)
          for (int x = 0; x < image.getWidth(); ++x)
              ++freq[0][raster.getSample(x, y, 0)];
    } else {
        int[] value = new int[3];
        for (int y = 0; y < image.getHeight(); ++y)
          for (int x = 0; x < image.getWidth(); ++x) {
              raster.getPixel(x, y, value);
              ++freq[0][value[0]];
              ++freq[1][value[1]];
              ++freq[2][value[2]];
          }
    }
}                                                                                     41
                 PsuedoColoring
Artifical coloring (PsuedoColoring) can often enhance the
presentation of image information

Replaces the gray-scale levels by an arbitrarily selected
palette or color bar




                                                            42
                             PsuedoColoring
Color Tables are arbitrarily selected Palettes of colors. There are ways to
automatically compute interesting palettes. Tables below were generated using
offset sinusoidal waves in each of the RGB bands


                    Pseudo   Color   Table                          Pseudo   Color   Table
           1                                               1


         0.8                                             0.8


         0.6                                             0.6


         0.4                                             0.4


         0.2                                             0.2



               50      100       150         200   250         50      100       150         200   250

                    Pseudo   Color   Table                          Pseudo   Color   Table
           1                                               1


         0.8                                             0.8


         0.6                                             0.6


         0.4                                             0.4


         0.2                                             0.2



               50      100       150         200   250         50      100       150         200   250
                                                                                                         43
                                PsuedoColoring

The color tables below were generated by using offset sinusoids
into each of the RGB bands.

              Pseudo    Color   Table                          Pseudo    Color   Table
     1                                                1

   0.8                                              0.8

   0.6                                              0.6

   0.4                                              0.4

   0.2                                              0.2


         50       100       150         200   250         50       100       150         200   250



              Pseudo    Color   Table                          Pseudo    Color   Table
     1                                                1

   0.8                                              0.8

   0.6                                              0.6

   0.4                                              0.4

   0.2                                              0.2


         50       100       150         200   250         50       100       150         200   250
                                                                                                     44
            Psuedo Coloring Example




Weather satellite image. Note the way the colorized image brings out certain
details that are difficult to distinguish in the original.
                                                                           45
                Psuedo Coloring Example
Source: Institue of Biotechnology, University of Helsinki, Mouse embryo 13 d pc, tissue section
                                       from molar tooth




The above tissue sample is colorized using two different color tables. Take
your pick!
                                                                                              46
              Image Averaging
consider a noisy image g(x,y) formed by the
addition of noise (x,y) to an original image f(x,y)


       g(x,y) = f(x,y) + (x,y)




                                                   47
             Image Averaging
if noise has zero mean and be uncorrelated then it
can be shown that if


      g ( x, y )   = image formed by averaging
                      K different noisy images


                          K
                     1
        g ( x, y ) 
                     K
                          g ( x, y )
                          i 1
                                 i



                                                 48
              Image Averaging
Note: the images gi(x,y) (noisy images) must be
registered (aligned) in order to avoid the
introduction of blurring and other artifacts in the
output image.




                                                      49
Example


   a) original image
   b) image corrupted by additive
   Gaussian noise with zero mean
   and a standard deviation of 64
   gray levels.
   c). -f). results of averaging K =
   8, 16, 64 and 128 noisy images


        a    b

        c    d

        e    f
                                 50
           Image Subtraction


            g(x,y) = f(x,y) – h(x,y)

Enhancement of the differences between images.




                                                 51
Image Substraction




                     52
Image Substraction




                     53
54

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:11
posted:8/18/2012
language:English
pages:54