---

lvlslice.c

Go to the documentation of this file.

#include        "sadie.h"

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function performs a level-slice classification on an image.         */
/*   Pixels lying within two or more boxes in feature space are assigned      */
/*   by the nearest-mean algorithm.                                           */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
LVLSLICE (IMAGE * in,           /*  I   Pointer to the input image.                           */
          PIXEL * grng,         /*  I   Matrix[nlev][nbnd][2], containing class boundaries.   */
          short nlev,           /*  I   Number of classes                                     */
          /*      (and number of graylevels in the output image).       */
          IMAGE ** out          /*  O   Address of a pointer to the output image.             */
          /*      The input image may be overwritten (out = &in).       */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k, l, index, count, assign, class;
  char msg[SLEN];
  PIXEL *center = 0, dnew, dold;

  if (TIMES)
    TIMING (T_LVLSLICE);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "LVLSLICE");
      MESSAGE ('I', "");
      sprintf (msg, " Input image:         %s", in->text);
      MESSAGE ('I', msg);
      sprintf (msg, " Number of classes:   %d", nlev);
      MESSAGE ('I', msg);
      sprintf (msg, "       ");
      for (i = 0; i < in->nbnd; i++)
        {
          sprintf (msg + strlen (msg), "          Band %-11d", i + 1);
        }
      MESSAGE ('I', msg);
      sprintf (msg, " Class");
      for (i = 0; i < in->nbnd; i++)
        {
          sprintf (msg + strlen (msg), "      Min         Max     ");
        }
      MESSAGE ('I', msg);
      for (i = 0; i < nlev; i++)
        {
          sprintf (msg, " %3d ", i + 1);
          for (j = 0; j < in->nbnd; j++)
            {
              sprintf (msg + strlen (msg), "%14.4e%12.4e",
                       grng[(i * in->nbnd + j) * 2 + 0],
                       grng[(i * in->nbnd + j) * 2 + 1]);
            }
          MESSAGE ('I', msg);
        }
      MESSAGE ('I', " ...............");
    }

  /* check input */
  if (!CHECKIMG (in))
    {
      MESSAGE ('E', " Can't identify image.");
      goto the_end;
    }
  else if (nlev <= 0)
    {
      MESSAGE ('E', " Number of classes must be greater than zero.");
      goto the_end;
    }

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

  /* allocate space for center array */
  if (!(center = (PIXEL *) malloc (nlev * in->nbnd * sizeof (PIXEL))))
    {
      MESSAGE ('E', " Memory request failed.");
      goto the_end;
    }

  /* compute center coordinates for each class  */
  for (j = i = 0; i < nlev * in->nbnd; i++)
    {
      center[i] = (grng[j++] + grng[j++]) / 2.0;
    }

  /* perform a level slice classification */
  for (j = 0; j < in->nlin; j++)
    {
      for (k = 0; k < in->npix; k++)
        {
          for (assign = index = class = l = 0; l < nlev; l++)
            {
              for (index = l * in->nbnd * 2, count = i = 0; i < in->nbnd; i++)
                {
                  if (grng[index++] <= in->data[i][j][k]
                      && in->data[i][j][k] <= grng[index++])
                    {
                      count += 1;
                    }
                  else
                    {
                      break;
                    }
                }
              if (count == in->nbnd)
                {
                  if (assign == 0)
                    {
                      class = l + 1;
                      assign = 1;
                    }
                  else          /* calculate distance to competing classes */
                    {
                      for (dold = dnew = 0.0, i = 0; i < in->nbnd; i++)
                        {
                          dold +=
                            (in->data[i][j][k] -
                             center[(class - 1) * in->nbnd +
                                    i]) * (in->data[i][j][k] - center[(class -
                                                                       1) *
                                                                      in->
                                                                      nbnd +
                                                                      i]);
                          dnew +=
                            (in->data[i][j][k] -
                             center[l * in->nbnd + i]) * (in->data[i][j][k] -
                                                          center[l *
                                                                 in->nbnd +
                                                                 i]);
                        }
                      if (dnew < dold)
                        class = l + 1;
                    }
                }
            }
          (*out)->data[0][j][k] = (PIXEL) class;
        }
    }

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

---