---

stretch.c

Go to the documentation of this file.

#include        "sadie.h"

extern PIXEL gmax;
extern PIXEL bias;
extern PIXEL gain;
extern PIXEL gbrk[2][4];
extern short nlev;
extern PIXEL gmin;
extern PIXEL *table;
extern PIXEL thresh;

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function performs a general graylevel transformation on an image,   */
/*   using a user-supplied or library transformation (TF...) function.        */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
STRETCH (IMAGE * in,            /*  I   Pointer to the input image.                           */
         short (*tf) (IMAGE *, IMAGE **),
         /*  I   Pointer to the transformation function.               */
         IMAGE ** out           /*  O   Address of a pointer to the output image.             */
         /*      The input image may be overwritten (out = &in).       */
/*----------------------------------------------------------------------------*/
  )
{
  register short i;
  char msg[SLEN];

  if (TIMES)
    TIMING (T_STRETCH);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "STRETCH");
      MESSAGE ('I', "");
      sprintf (msg, " Input image:   %s", in->text);
      MESSAGE ('I', msg);
      if (tf == TFINVERT)
        {
          MESSAGE ('I', " Inverse stretch");
          sprintf (msg, " Graylevel maximum:   %12.4e", gmax);
          MESSAGE ('I', msg);
        }
      else if (tf == TFLINEAR)
        {
          MESSAGE ('I', " Linear stretch");
          sprintf (msg, " Bias: %12.4e", bias);
          MESSAGE ('I', msg);
          sprintf (msg, " Gain: %12.4e", gain);
          MESSAGE ('I', msg);
        }
      else if (tf == TFLOG)
        {
          MESSAGE ('I', " Logarithmic stretch");
        }
      else if (tf == TFPLT)
        {
          MESSAGE ('I', " Piecewise linear stretch");
          sprintf (msg, " Input graylevel breakpoints: ");
          for (i = 0; i < 4; i++)
            {
              sprintf (msg + strlen (msg), "%12.4e", gbrk[0][i]);
            }
          MESSAGE ('I', msg);
          sprintf (msg, " Output graylevel breakpoints:");
          for (i = 0; i < 4; i++)
            {
              sprintf (msg + strlen (msg), "%12.4e", gbrk[1][i]);
            }
          MESSAGE ('I', msg);
        }
      else if (tf == TFQUANT)
        {
          MESSAGE ('I', " Requantize graylevels");
          sprintf (msg, " Minimum graylevel:  %12.4e", gmin);
          MESSAGE ('I', msg);
          sprintf (msg, " Maximum graylevel:  %12.4e", gmax);
          MESSAGE ('I', msg);
          sprintf (msg, " Quantization steps:   %d", nlev);
          MESSAGE ('I', msg);
        }
      else if (tf == TFROOT)
        {
          MESSAGE ('I', " Square root stretch");
        }
      else if (tf == TFSAT)
        {
          MESSAGE ('I', " Saturate graylevels");
          sprintf (msg, " Graylevel minimum threshold:   %12.4e", gmin);
          MESSAGE ('I', msg);
          sprintf (msg, " Graylevel maximum threshold:   %12.4e", gmax);
          MESSAGE ('I', msg);
        }
      else if (tf == TFSCALE)
        {
          MESSAGE ('I', " Linear stretch");
          sprintf (msg, " New minimum graylevel:   %12.4e", gmin);
          MESSAGE ('I', msg);
          sprintf (msg, " New maximum graylevel:   %12.4e", gmax);
          MESSAGE ('I', msg);
        }
      else if (tf == TFSQUARE)
        {
          MESSAGE ('I', " Square stretch");
        }
      else if (tf == TFTABLE)
        {
          MESSAGE ('I', " Table lookup stretch");
          MESSAGE ('I', " Lookup table:   index    value");
          for (i = (short) floor (in->gmin); i <= (short) floor (in->gmax);
               i++)
            {
              sprintf (msg, " %20d %12.4e", i,
                       table[i - (short) floor (in->gmin)]);
              MESSAGE ('I', msg);
            }
        }
      else if (tf == TFTHRESH)
        {
          MESSAGE ('I', " Threshold graylevels");
          sprintf (msg, " Graylevel threshold:   %12.4e", thresh);
          MESSAGE ('I', msg);
        }
      MESSAGE ('I', " ...............");
    }

  /* check input */
  if (!CHECKIMG (in))
    {
      MESSAGE ('E', " Can't identify image.");
      goto the_end;
    }
  else if (!tf)
    {
      MESSAGE ('E', " Can't identify transformation function.");
      goto the_end;
    }

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

  /* transform the image */
  (*tf) (in, out);

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function inverts the graylevels in an image by subtracting  */
/*   them from a user-supplied maximum graylevel.                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL gmax;              /*  I   Maximum graylevel.                            */
short
TFINVERT (IMAGE * in,           /*  I   Pointer to the input image.                           */
          IMAGE ** out          /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFINVERT);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] = gmax - in->data[i][j][k];
            }
        }
    }
  (*out)->gmin = gmax - in->gmax;
  (*out)->gmax = gmax - in->gmin;

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a linear graylevel transformation.        */
/*   The transformation equation is:    pixel  =  bias + gain * pixel.        */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL bias;              /*  I   Graylevel bias.                               */
extern PIXEL gain;              /*  I   Graylevel gain.                               */
short
TFLINEAR (IMAGE * in,           /*  I   Pointer to the input image.                           */
          IMAGE ** out          /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFLINEAR);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                (PIXEL) ((double) gain * (double) in->data[i][j][k] +
                         (double) bias);
            }
        }
    }
  if (gain >= 0.0)
    {
      (*out)->gmin =
        (PIXEL) ((double) gain * (double) in->gmin + (double) bias);
      (*out)->gmax =
        (PIXEL) ((double) gain * (double) in->gmax + (double) bias);
    }
  else
    {
      (*out)->gmin =
        (PIXEL) ((double) gain * (double) in->gmax + (double) bias);
      (*out)->gmax =
        (PIXEL) ((double) gain * (double) in->gmin + (double) bias);
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a log(base10) graylevel transformation.   */
/*   Input pixels with a graylevel of zero or less are simply retained.       */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short
TFLOG (IMAGE * in,              /*  I   Pointer to the input image.                           */
       IMAGE ** out             /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFLOG);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                in->data[i][j][k] <=
                0.0 ? in->data[i][j][k] : (PIXEL) log10 ((double) in->
                                                         data[i][j][k] + 1.0);
            }
        }
    }
  (*out)->gmin =
    in->gmin <= 0.0 ? in->gmin : (PIXEL) log10 ((double) in->gmin + 1.0);
  (*out)->gmax =
    in->gmax <= 0.0 ? in->gmax : (PIXEL) log10 ((double) in->gmax + 1.0);

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a three-segment, piecewise linear         */
/*   transformation.                                                          */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL gbrk[2][4];        /*  I   A matrix[2][4], containing the                */
                        /*      input  graylevel breakpoints (gbrk[0][0..3]), */
                        /*      output graylevel breakpoints (gbrk[1][0..3]). */
short
TFPLT (IMAGE * in,              /*  I   Pointer to the input image.                           */
       IMAGE ** out             /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;
  double s1, s2, s3, b1, b2, b3;

  if (TIMES)
    TIMING (T_TFPLT);

  s1 =
    (double) (gbrk[1][1] - gbrk[1][0]) / (double) (gbrk[0][1] - gbrk[0][0]);
  s2 =
    (double) (gbrk[1][2] - gbrk[1][1]) / (double) (gbrk[0][2] - gbrk[0][1]);
  s3 =
    (double) (gbrk[1][3] - gbrk[1][2]) / (double) (gbrk[0][3] - gbrk[0][2]);
  b1 = (double) gbrk[1][0] - (double) gbrk[0][0] * s1;
  b2 = (double) gbrk[1][1] - (double) gbrk[0][1] * s2;
  b3 = (double) gbrk[1][2] - (double) gbrk[0][2] * s3;
  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              if (in->data[i][j][k] <= gbrk[0][1])
                {
                  (*out)->data[i][j][k] =
                    max ((PIXEL) (s1 * (double) in->data[i][j][k] + b1),
                         gbrk[1][0]);
                }
              else if (in->data[i][j][k] <= gbrk[0][2])
                {
                  (*out)->data[i][j][k] =
                    (PIXEL) (s2 * (double) in->data[i][j][k] + b2);
                }
              else
                {
                  (*out)->data[i][j][k] =
                    min ((PIXEL) (s3 * (double) in->data[i][j][k] + b3),
                         gbrk[1][3]);
                }
            }
        }
    }
  if (in->gmin <= gbrk[0][1])
    {
      (*out)->gmin = max ((PIXEL) (s1 * (double) in->gmin + b1), gbrk[1][0]);
    }
  else if (in->gmin <= gbrk[0][2])
    {
      (*out)->gmin = (PIXEL) (s2 * (double) in->gmin + b2);
    }
  else
    {
      (*out)->gmin = min ((PIXEL) (s3 * (double) in->gmin + b3), gbrk[1][3]);
    }
  if (in->gmax <= gbrk[0][1])
    {
      (*out)->gmax = max ((PIXEL) (s1 * (double) in->gmax + b1), gbrk[1][0]);
    }
  else if (in->gmax <= gbrk[0][2])
    {
      (*out)->gmax = (PIXEL) (s2 * (double) in->gmax + b2);
    }
  else
    {
      (*out)->gmax = min ((PIXEL) (s3 * (double) in->gmax + b3), gbrk[1][3]);
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function quantizes graylevels between a specified range.    */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern short nlev;              /*  I   Number of graylevels in the output image.     */
extern PIXEL gmin;              /*  I   Minimum input graylevel.                      */
extern PIXEL gmax;              /*  I   Maximum input graylevel.                      */
short
TFQUANT (IMAGE * in,            /*  I   Pointer to the input image.                           */
         IMAGE ** out           /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;
  double factor;

  if (TIMES)
    TIMING (T_TFQUANT);

  factor = (double) (--nlev) / (double) (gmax - gmin);
  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                (PIXEL) max (0,
                             min ((short)
                                  ((double) (in->data[i][j][k] - gmin) *
                                   factor), nlev));
            }
        }
    }
  (*out)->gmin = (PIXEL) 0;
  (*out)->gmax = (PIXEL) nlev;

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a square-root graylevel transformation.   */
/*   Input pixels with a graylevel less than zero are simply retained.        */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short
TFROOT (IMAGE * in,             /*  I   Pointer to the input image.                           */
        IMAGE ** out            /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFROOT);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                in->data[i][j][k] <
                0.0 ? in->data[i][j][k] : (PIXEL) sqrt ((double) in->
                                                        data[i][j][k]);
            }
        }
    }
  (*out)->gmin = in->gmin < 0.0 ? in->gmin : (PIXEL) sqrt ((double) in->gmin);
  (*out)->gmax = in->gmax < 0.0 ? in->gmax : (PIXEL) sqrt ((double) in->gmax);

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1990 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a graylevel saturation transformation.    */
/*   Graylevels within the specified range are retained, all others are       */
/*   saturated at the appropriate range boundary.                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL gmin;              /*  I   Lower graylevel threshold.                    */
extern PIXEL gmax;              /*  I   Upper graylevel threshold.                    */
short
TFSAT (IMAGE * in,              /*  I   Pointer to the input image.                           */
       IMAGE ** out             /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFSAT);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              if (in->data[i][j][k] < gmin)
                {
                  (*out)->data[i][j][k] = gmin;
                }
              else if (in->data[i][j][k] < gmax)
                {
                  (*out)->data[i][j][k] = in->data[i][j][k];
                }
              else
                {
                  (*out)->data[i][j][k] = gmax;
                }
            }
        }
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a linear graylevel transformation.        */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL gmin;              /*  I   New minimum graylevel.                        */
extern PIXEL gmax;              /*  I   New maximum graylevel.                        */
short
TFSCALE (IMAGE * in,            /*  I   Pointer to the input image.                           */
         IMAGE ** out           /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;
  double factor;

  if (TIMES)
    TIMING (T_TFSCALE);

  RANGE (in);
  factor =
    in->gmin <
    in->gmax ? (double) (gmax - gmin) / (double) (in->gmax - in->gmin) : 0.0;
  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                (PIXEL) ((double) (in->data[i][j][k] - in->gmin) * factor) +
                gmin;
            }
        }
    }
  if (gmin <= gmax)
    {
      (*out)->gmin = gmin;
      (*out)->gmax = gmax;
    }
  else
    {
      (*out)->gmin = gmax;
      (*out)->gmax = gmin;
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a graylevel-square transformation.        */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short
TFSQUARE (IMAGE * in,           /*  I   Pointer to the input image.                           */
          IMAGE ** out          /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFSQUARE);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] = in->data[i][j][k] * in->data[i][j][k];
            }
        }
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a graylevel transformation via            */
/*   table look-up.                                                           */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL *table;            /*  I   Pointer to an array of size                   */
                        /*      floor(in->gmax) - floor(in->gmin) + 1,        */
                        /*      containing the look-up table.                 */
short
TFTABLE (IMAGE * in,            /*  I   Pointer to the input image.                           */
         IMAGE ** out           /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k, offset;

  if (TIMES)
    TIMING (T_TFTABLE);

  offset = (short) floor ((double) in->gmin);
  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                table[(short) floor ((double) in->data[i][j][k]) - offset];
            }
        }
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This library function performs a binary graylevel threshold              */
/*   transformation.                                                          */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
extern PIXEL thresh;            /*  I   Graylevel threshold.                          */
short
TFTHRESH (IMAGE * in,           /*  I   Pointer to the input image.                           */
          IMAGE ** out          /*  O   Address of a pointer to the output image.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;

  if (TIMES)
    TIMING (T_TFTHRESH);

  for (i = 0; i < in->nbnd; i++)
    {
      for (j = 0; j < in->nlin; j++)
        {
          for (k = 0; k < in->npix; k++)
            {
              (*out)->data[i][j][k] =
                in->data[i][j][k] < thresh ? in->gmin : in->gmax;
            }
        }
    }
  (*out)->gmin = in->gmin < thresh ? in->gmin : in->gmax;
  (*out)->gmax = in->gmax < thresh ? in->gmin : in->gmax;

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

---