---

window.c

Go to the documentation of this file.

#include        "sadie.h"

extern short csize;
extern PIXEL thresh;
extern double weight;

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function performs a user-specified neighborhood operation using     */
/*   a moving window. Several library operations (WTF...) are available.      */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
WINDOW (IMAGE * in,             /*  I   Pointer to the input image.                           */
        PIXEL (*wtf) (PIXEL *, short, short),
        /*  I   Address of the filter function.                       */
        short jsize,            /*  I   Number of lines in the window.                        */
        short ksize,            /*  I   Number of pixels/line in the window.                  */
        IMAGE ** out            /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k, l, m, n, jmarg = (jsize - 1) / 2, kmarg =
    (ksize - 1) / 2;
  char msg[SLEN];
  PIXEL *wnd = 0;
  double pinc, psum;

  if (TIMES)
    TIMING (T_WINDOW);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "WINDOW");
      MESSAGE ('I', "");
      sprintf (msg, " Input image:           %s", in->text);
      MESSAGE ('I', msg);
      sprintf (msg, " Window size: lines:    %d", jsize);
      MESSAGE ('I', msg);
      sprintf (msg, "              pixels:   %d", ksize);
      MESSAGE ('I', msg);
      if (wtf == WTFCAVG)
        {
          MESSAGE ('I', " Conditional average filter");
          sprintf (msg, " Set size threshold:               %d", csize);
          MESSAGE ('I', msg);
          sprintf (msg, " Graylevel difference threshold: %12.4e", thresh);
          MESSAGE ('I', msg);
        }
      else if (wtf == WTFDIVER)
        {
          MESSAGE ('I', " Diversity map");
        }
      else if (wtf == WTFMAJ)
        {
          MESSAGE ('I', " Majority filter");
          sprintf (msg, " Center pixel weight: %12.4e", weight);
          MESSAGE ('I', msg);
        }
      else if (wtf == WTFMAX)
        {
          MESSAGE ('I', " Maximum filter");
        }
      else if (wtf == WTFMIN)
        {
          MESSAGE ('I', " Minimum filter");
        }
      else if (wtf == WTFVAR)
        {
          MESSAGE ('I', " Variance map");
        }
      MESSAGE ('I', " ...............");
    }

  /* check input */
  if (!CHECKIMG (in))
    {
      MESSAGE ('E', " Can't identify image.");
      goto the_end;
    }
  else if (!wtf)
    {
      MESSAGE ('E', " Can't identify window function.");
      goto the_end;
    }
  else if (jsize <= 0 || jsize % 2 == 0)
    {
      MESSAGE ('E',
               " Window line size must be an odd number greater than zero.");
      goto the_end;
    }
  else if (jsize > in->nlin)
    {
      MESSAGE ('E',
               " Image line size must be equal to or greater than window line size.");
      goto the_end;
    }
  else if (ksize <= 0 || ksize % 2 == 0)
    {
      MESSAGE ('E',
               " Window pixel size must be an odd number greater than zero.");
      goto the_end;
    }
  else if (ksize > in->npix)
    {
      MESSAGE ('E',
               " Image pixel size must be equal to or greater than window pixel size.");
      goto the_end;
    }

  /* create image of appropriate size */
  if (!CHECKIMG (*out))
    GETMEM (in->nbnd, in->nlin, in->npix, out);
  if (!*out)
    goto the_end;

  /* allocate space for 1-D array */
  if (!(wnd = (PIXEL *) malloc (jsize * ksize * sizeof (PIXEL))))
    {
      MESSAGE ('E', " Memory request failed.");
      goto the_end;
    }

  /* initialize progress indicator */
  if (LINES && !PROGRESS (psum = 0.0))
    goto the_end;
  pinc = 1.0 / (double) in->nbnd / (double) (in->nlin - 2 * jmarg);

  /* put pixels inside window into array and call the window function */
  for (i = 0; i < in->nbnd; i++)
    {
      for (j = jmarg; j < in->nlin - jmarg; j++)
        {
          for (k = kmarg; k < in->npix - kmarg; k++)
            {
              for (n = 0, l = j - jmarg; l <= j + jmarg; l++)
                {
                  for (m = k - kmarg; m <= k + kmarg; m++)
                    {
                      wnd[n++] = in->data[i][l][m];
                    }
                }
              (*out)->data[i][j][k] = (*wtf) (wnd, jsize, ksize);
            }
          if (LINES && !PROGRESS (psum += pinc))
            goto the_end;
        }

      /* fill top and bottom margins */
      for (j = 0; j < jmarg; j++)
        {
          for (k = kmarg; k < in->npix - kmarg; k++)
            {
              (*out)->data[i][j][k] = (*out)->data[i][jmarg][k];
              (*out)->data[i][in->nlin - j - 1][k] =
                (*out)->data[i][in->nlin - jmarg - 1][k];
            }
        }

      /* fill left and right margins */
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < kmarg; k++)
            {
              (*out)->data[i][j][k] = (*out)->data[i][j][kmarg];
              (*out)->data[i][j][in->npix - k - 1] =
                (*out)->data[i][j][in->npix - kmarg - 1];
            }
        }
    }

the_end:
  if (wnd)
    free (wnd);
  if (TIMES)
    TIMING (T_EXIT);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1990 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function computes a local conditional average filter.       */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Background Information-----------------------------------------------------*/
/*                                                                            */
/*   Ryan, T.W.:                                                              */
/*   "Image Segmentation Algorithms."                                         */
/*   SPIE, Vol. 534, pp. 172-178, 1985                                        */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern short csize;             /*  I   Threshold for size of center pixel set.       */
extern PIXEL thresh;            /*  I   Graylevel difference threshold.               */
PIXEL
WTFCAVG (PIXEL * wnd,           /*  I   Pointer to the window matrix[jsize][ksize].           */
         short jsize,           /*  I   Number of lines in the window.                        */
         short ksize            /*  I   Number of pixels/line in the window.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, count = 0;
  PIXEL center = wnd[jsize / 2 * ksize + ksize / 2], sum1 = (PIXEL) 0, sum2 =
    (PIXEL) 0, minval = wnd[0], maxval = wnd[0];

  if (TIMES)
    TIMING (T_WTFCAVG);

  /* compute conditional average */
  for (i = 0; i < jsize * ksize; i++)
    {
      if ((PIXEL) fabs ((double) (wnd[i] - center)) <= thresh)
        {
          sum1 += wnd[i];
          count += 1;
        }
      else if (csize != 0)
        {
          sum2 += wnd[i];
          minval = min (minval, wnd[i]);
          maxval = max (maxval, wnd[i]);
        }
    }
  if (csize == 0 || count > csize)
    {
      center = (PIXEL) ((double) sum1 / (double) count);
    }
  else if (csize != 0 && (PIXEL) fabs ((double) (maxval - minval)) <= thresh)
    {
      center = (PIXEL) ((double) sum2 / (double) (jsize * ksize - count));
    }

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return (center);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function computes the local graylevel diversity.            */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
PIXEL
WTFDIVER (PIXEL * wnd,          /*  I   Pointer to the window matrix[jsize][ksize].           */
          short jsize,          /*  I   Number of lines in the window.                        */
          short ksize           /*  I   Number of pixels/line in the window.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, diversity = 0;

  if (TIMES)
    TIMING (T_WTFDIVER);

  for (i = 0; i < jsize * ksize; i++)
    {
      for (++diversity, j = 0; j < i; j++)
        {
          if (wnd[i] == wnd[j])
            {
              diversity -= 1;
              break;
            }
        }
    }

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return ((PIXEL) diversity);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function computes a local majority filter.                  */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Background Information-----------------------------------------------------*/
/*                                                                            */
/*   Schowengerdt, R.A.:                                                      */
/*   "Techniques for Image Processing and Classification in Remote Sensing."  */
/*   Academic Press, New York, 1983, pp. 188-190                              */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern short nlev;              /*  I   Number of graylevels in the input image.      */
extern PIXEL gmin;              /*  I   Minimum graylevel in the input image.         */
extern double weight;           /*  I   Class count weight of the center pixel.       */
extern double *count;           /*  O   Pointer to an array[nlev], containing         */
                        /*      the weighted number of pixels for each class. */
PIXEL
WTFMAJ (PIXEL * wnd,            /*  I   Pointer to the window matrix[jsize][ksize].           */
        short jsize,            /*  I   Number of lines in the window.                        */
        short ksize             /*  I   Number of pixels/line in the window.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, pclass, center =
    (short) (wnd[jsize / 2 * ksize + ksize / 2] - gmin);
  double plurality;

  if (TIMES)
    TIMING (T_WTFMAJ);

  /* initialize counter array */
  for (i = 0; i < nlev; count[i++] = 0.0);

  /* count number of pixels in each class */
  for (i = 0; i < jsize * ksize; i++)
    {
      count[(short) (wnd[i] - gmin)] += 1.0;
    }

  /* weight center pixel class */
  count[center] *= weight;

  /* find plurality class and make sure that plurality > simple majority and that plurality is unique */
  for (plurality = count[pclass = 0], i = 1; i < nlev; i++)
    {
      if (count[i] > plurality && i != center)
        plurality = count[pclass = i];
    }
  if (plurality <= (double) (jsize * ksize) / 2.0
      || plurality <= count[center])
    pclass = center;

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return ((PIXEL) pclass + gmin);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function computes a local maximum filter.                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
PIXEL
WTFMAX (PIXEL * wnd,            /*  I   Pointer to the window matrix[jsize][ksize].           */
        short jsize,            /*  I   Number of lines in the window.                        */
        short ksize             /*  I   Number of pixels/line in the window.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i;
  PIXEL maxval = wnd[0];

  if (TIMES)
    TIMING (T_WTFMAX);

  /* find local maximum */
  for (i = 1; i < jsize * ksize; i++)
    {
      maxval = max (maxval, wnd[i]);
    }

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return (maxval);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function computes a local minimum filter.                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
PIXEL
WTFMIN (PIXEL * wnd,            /*  I   Pointer to the window matrix[jsize][ksize].           */
        short jsize,            /*  I   Number of lines in the window.                        */
        short ksize             /*  I   Number of pixels/line in the window.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i;
  PIXEL minval = wnd[0];

  if (TIMES)
    TIMING (T_WTFMIN);

  /* find local minimum */
  for (i = 1; i < jsize * ksize; i++)
    {
      minval = min (minval, wnd[i]);
    }

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return (minval);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function computes a local variance map.                     */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
PIXEL
WTFVAR (PIXEL * wnd,            /*  I   Pointer to the window matrix[jsize][ksize].           */
        short jsize,            /*  I   Number of lines in the window.                        */
        short ksize             /*  I   Number of pixels/line in the window.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i;
  double area = jsize * ksize;
  PIXEL sum = (PIXEL) 0, sumsq = (PIXEL) 0;

  if (TIMES)
    TIMING (T_WTFVAR);

  for (i = 0; i < jsize * ksize; i++)
    {
      sum += wnd[i];
      sumsq += wnd[i] * wnd[i];
    }

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return ((PIXEL)
          ((double) sumsq / area -
           ((double) sum / area) * ((double) sum / area)));
}

---