---

control.c

Go to the documentation of this file.

#include        <stdio.h>
#include            <malloc.h>
#include            <tcl.h>
#include        "sadie.h"

/*
##########################################
# control.c -
#   File from the SADIE library.  Updated for use on UNIX and
#   in tclSadie.
#
# RCS: $Id: control.c,v 2.4 2000/08/08 22:54:32 giri Exp $ 
# 
# Digital Image Analysis Lab
# Dept. of Electrical and Computer Engineering
# University of Arizona
##########################################
*/

/* RCS Indentification information */
static char rcsid[] = "$Id: control.c,v 2.4 2000/08/08 22:54:32 giri Exp $";

/* Added 4/2/97 by S.Conner */
extern char *msg_ptr;
extern Tcl_Interp *MainTclInterp;

char *functions[T_END][2] = { {"", ""},
{"BILTOBSQ", "biltobsq.c"},
{"BSQTOBIL", "bsqtobil.c"},
{"CHECKER", "checker.c"},
{"CHECKIMG", "control.c"},
{"CHIRP", "chirp.c"},
{"CLUSTER", "cluster.c"},
{"COM2REAL", "com2real.c"},
{"COMBINE", "combine.c"},
{"COMPARE", "compare.c"},
{"CONTNORM", "contnorm.c"},
{"CONTOUR", "contour.c"},
{"COVAR", "covar.c"},
{"CSPLINE", "geomwarp.c"},
{"DECORSTR", "decorstr.c"},
{"DESTRIPE", "destripe.c"},
{"DISK2IMG", "disk2img.c"},
{"DSPL2IMG", "dspl2img.c"},
{"DUPL", "dupl.c"},
{"EDGE", "edge.c"},
{"EIGEN", "eigen.c"},
{"EXPAND", "expand.c"},
{"FCONVL", "fconvl.c"},
{"FFT1D", "fft2d.c"},
{"FFT2D", "fft2d.c"},
{"FHT1D", "fht2d.c"},
{"FHT2D", "fht2d.c"},
{"FILTER", "filter.c"},
{"FINI", "control.c"},
{"FLTBOX", "filter.c"},
{"FLTCONE", "filter.c"},
{"FLTCYL", "filter.c"},
{"FLTEXP", "filter.c"},
{"FLTGAUSS", "filter.c"},
{"FUNCTION", "function.c"},
{"GEOMCOEF", "geomcoef.c"},
{"GEOMWARP", "geomwarp.c"},
{"GETMEM", "control.c"},
{"GRADIENT", "gradient.c"},
{"GRAYSCAL", "grayscal.c"},
{"GRID", "grid.c"},
{"HELP", "control.c"},
{"HISTEQ", "histeq.c"},
{"HISTOGRM", "histogrm.c"},
{"HMOSAIC", "hmosaic.c"},
{"HSVTORGB", "hsvtorgb.c"},
{"IMG2DISK", "img2disk.c"},
{"IMG2DSPL", "img2dspl.c"},
{"IMG2EPSF", "img2epsf.c"},
{"IMG2PICT", "img2pict.c"},
{"IMG2TAPE", "img2tape.c"},
{"IMG2TEXT", "img2text.c"},
{"IMG2TIFF", "img2tiff.c"},
{"IMG2VECT", "img2vect.c"},
{"INFO", "info.c"},
{"INIT", "control.c"},
{"INSERT", "insert.c"},
{"MATRIX_INVERT", "matrix_invert.c"},
{"LABEL", "label.c"},
{"LVLSLICE", "lvlslice.c"},
{"MAIN", ""},
{"MATCH", "match.c"},
{"MAXLIKE", "maxlike.c"},
{"MEDIAN", "median.c"},
{"MESSAGE", "control.c"},
{"MOSAIC", "mosaic.c"},
{"MINDIST", "mindist.c"},
{"PACK", "control.c"},
{"PCT", "pct.c"},
{"PICT2IMG", "pict2img.c"},
{"PIXLDUMP", "pixldump.c"},
{"PLOT", "plot.c"},
{"PROGRESS", "control.c"},
{"PSPECT", "pspect.c"},
{"PSPECT1D", "pspect.c"},
{"RANDOM", "random.c"},
{"RANGE", "control.c"},
{"REAL2COM", "real2com.c"},
{"REFINE", "refine.c"},
{"RELIEF", "relief.c"},
{"RELIMG", "control.c"},
{"RELMEM", "control.c"},
{"RESAMPL", "resampl.c"},
{"RGBTOHSV", "rgbtohsv.c"},
{"RMSDIFF", "rmsdiff.c"},
{"ROISTATS", "roistats.c"},
{"ROTATE", "rotate.c"},
{"SCATTER", "scatter.c"},
{"SCONVL", "sconvl.c"},
{"SEGMENT", "segment.c"},
{"SIGMAP", "sigmap.c"},
{"SINESTAR", "sinestar.c"},
{"SINEWAVE", "sinewave.c"},
{"STATS", "stats.c"},
{"STRETCH", "stretch.c"},
{"SUBSAMPL", "subsampl.c"},
{"SWAP", "control.c"},
{"TAPE2IMG", "tape2img.c"},
{"TEST", ""},
{"TFINVERT", "stretch.c"},
{"TFLINEAR", "stretch.c"},
{"TFLOG", "stretch.c"},
{"TFPLT", "stretch.c"},
{"TFQUANT", "stretch.c"},
{"TFROOT", "stretch.c"},
{"TFSAT", "stretch.c"},
{"TFSCALE", "stretch.c"},
{"TFSQUARE", "stretch.c"},
{"TFTABLE", "stretch.c"},
{"TFTHRESH", "stretch.c"},
{"TIFF2IMG", "tiff2img.c"},
{"TIMING", "control.c"},
{"TRNSFORM", "trnsform.c"},
{"UNPACK", "control.c"},
{"VECT2IMG", "vect2img.c"},
{"VMOSAIC", "vmosaic.c"},
{"VSTRETCH", "vstretch.c"},
{"WINDOW", "window.c"},
{"WTFCAVG", "window.c"},
{"WTFDIVER", "window.c"},
{"WTFMAJ", "window.c"},
{"WTFMAX", "window.c"},
{"WTFMIN", "window.c"},
{"WTFVAR", "window.c"}
};

typedef struct _list
{                               /* Data structure for tracking images */
  IMAGE *image;
  struct _list *next;
} list;

short ABORT = FALSE;            /* Added by SBA, 11-02-90 */

static short i = 0, w = 0, e = 0;       /* Message counts */

static short top = 0;           /* Number of functions on the stack */

static short stack[T_END];      /* Stack of function calls */

static long calls[T_END];       /* Number of calls per function */

static long actms[T_END];       /* Accumulated times per function */

static FILE *sys = NULL;        /* Pointer to system log-file */

static list *img = NULL;        /* List of allocated images */

#ifdef WINNT
int
rint (double value)
{
  int result;

  if (value > 0.0)
    {
      result = (int) (value + 0.5);
    }
  else
    {
      result = (int) (value - 0.5);
    }
}
#endif

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function initializes a SADIE program and must be called before      */
/*   any other SADIE function. If desired, global system variables must       */
/*   be set before this function is called.                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
char *SLOG = NULL;              /*  I   Name of the system log-file.                  */
short NAMES = ON;               /*  I   Switch, giving amount of log-file output:     */
                        /*      ON    -   function names are listed.          */
                        /*      OFF   -   function names are suppressed.      */
short TIMES = OFF;              /*  I   Switch, giving status of timing facility:     */
                        /*      ON    -   timing enabled.                     */
                        /*      OFF   -   timing disabled.                    */
short LINES = OFF;              /*  I   Switch, giving status of progress indicator:  */
                        /*      ON    -   progress indicator enabled.         */
                        /*      OFF   -   progress indicator disabled.        */
void
INIT ()
/*----------------------------------------------------------------------------*/
{
  char msg[SLEN];

  /* open log-file */
  if (SLOG == NULL || (sys = fopen (SLOG, "w+")) == NULL)
    {
      sys = stdout;
    }

  TIMING (T_MAIN);
  if (TIMES)
    TIMING (T_INIT);

  if (NAMES)
    {
      MESSAGE ('I', "INIT");
      MESSAGE ('I', "");
    }
  MESSAGE ('I', LOCALE);
  MESSAGE ('I', SYSTEM);
  MESSAGE ('I', "");
  sprintf (msg, " %.*s", strlen (ctime (actms)) - 1, ctime (actms));
  MESSAGE ('I', msg);

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function terminates a SADIE program.                                */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
FINI ()
/*----------------------------------------------------------------------------*/
{
  char msg[SLEN];

  if (TIMES)
    TIMING (T_FINI);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "FINI");
    }

  /* release all remaining images */
  while (img)
    RELMEM (img->image);

  /* output termination status */
  if (e || w)
    {
      sprintf (msg, " SADIE terminated with %d warning(s) and %d error(s).",
               w, e);
    }
  else
    {
      sprintf (msg, " SADIE completed successfully.");
    }
  MESSAGE ('I', "");
  MESSAGE ('I', msg);

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

  if (sys != NULL && sys != stdout)
    {
      fclose (sys);
    }
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function handles the output for all SADIE functions,      */
/*   with the exception of image display.                                     */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
MESSAGE (char option,           /*  I   Switch, indicating the type of output:                */
         /*      'I'   -   Informational message.                      */
         /*      'W'   -   Warning.                                    */
         /*      'E'   -   Error.                                      */
         char *msg              /*  I   Pointer to an array[*] of characters, containing      */
         /*      one line of output (without terminating '\n').        */
/*----------------------------------------------------------------------------*/
  )
{

/* Modified 4/2/97 by S.Conner */

  if (TIMES)
    TIMING (T_MESSAGE);

  /* update error counts and output message to log-file */
  switch (option)
    {
    case 'E':
      e += 1;
      /* fprintf(sys,"%c:   %s\n",option,msg); */
      sprintf (msg_ptr, "tk_dialog .dlg \"Warning\" \"%s\" warning 0 OK",
               msg);
      Tcl_GlobalEval (MainTclInterp, msg_ptr);

      sprintf (msg_ptr, "set SadieVar(message) \"%c:   %s\"", option, msg);
      break;
    case 'W':
      w += 1;
      /* fprintf(sys,"%c:   %s\n",option,msg); */
      sprintf (msg_ptr, "set SadieVar(message) \"%c:   %s\"", option, msg);
      break;
    case 'I':
      i += 1;
      /* fprintf(sys,"%c:   %s\n",option,msg); */
      sprintf (msg_ptr, "set SadieVar(message) \"%c:   %s\"", option, msg);
      break;
    default:
      /* fprintf(sys,"%s",msg); */
      sprintf (msg_ptr, "set SadieVar(message) \"%s\"", msg);
      break;
    }

the_end:

  Tcl_GlobalEval (MainTclInterp, msg_ptr);

  if (TIMES)
    TIMING (T_EXIT);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function provides a timing facility for SADIE.            */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
TIMING (option)
     T_TIME option;             /*  I   Switch, indicating the calling function.              */
/*----------------------------------------------------------------------------*/
{
  register short i;
  char msg[SLEN];
  long cur_time = time (NULL);

  /* update time-keeping */
  actms[stack[top]] += cur_time;
  stack[option ? calls[option]++, ++top : top--] = option;
  actms[stack[top]] -= cur_time;

  /* output statistics */
  if (top == 0 && TIMES == ON)
    {
      TIMES = OFF;
      if (NAMES)
        {
          MESSAGE ('I', "");
          MESSAGE ('I', "TIMING");
        }
      MESSAGE ('I', "");
      MESSAGE ('I', " Function  # of calls      Elapsed time    Time in %");
      MESSAGE ('I', "");
      for (i = 1; i < T_END; i++)
        {
          if (calls[i])
            {
              sprintf (msg, " %-8s%8ld            %02ld:%02ld:%02ld%13.1f",
                       functions[i][0], calls[i], actms[i] / 3600L,
                       actms[i] / 60L - 60L * (actms[i] / 3600L),
                       actms[i] % 60L,
                       (actms[0] ? -(double) actms[i] / (double) actms[0] *
                        100.0 : 0.0));
              MESSAGE ('I', msg);
            }
        }
    }
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1989 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function provides a progress indicator for SADIE.         */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short
PROGRESS (pct)
     double pct;                /*  I   Percentage of work completed (0.0 <= pct <= 1.0).     */
/*----------------------------------------------------------------------------*/
{
  if (TIMES)
    TIMING (T_PROGRESS);

  /* output percentage */
  fprintf (stderr, "%3d%%\b\b\b\b", (int) (100.0 * pct));
  fflush (stderr);

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-Programmer Information-----------------------------------------------------*/
/*                                                                            */
/*   The number and size of images that may be allocated from a program is    */
/*   system-dependent. However, this code will work on any system without     */
/*   modifications.                                                           */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function allocates memory for a new image, and            */
/*   initializes its data structure.                                          */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
GETMEM (short nbnd,             /*  I   Number of bands.                                      */
        short nlin,             /*  I   Number of lines.                                      */
        short npix,             /*  I   Number of pixels/line.                                */
        IMAGE ** out            /*  O   Address of a pointer to the image being allocated.    */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j;
  long total;
  BYTE *ptr = NULL;
  list *link = NULL;

  if (TIMES)
    TIMING (T_GETMEM);

  /* allocate space for image data structure, image data and list entry */
  total =
    sizeof (IMAGE) + nbnd * sizeof (PIXEL **) +
    nbnd * nlin * sizeof (PIXEL *) + nbnd * nlin * npix * sizeof (PIXEL) +
    sizeof (list);
  if (total < 0L)
    {
      MESSAGE ('E', " Memory request failed.");
      goto the_end;
    }
  if (!(ptr = (BYTE *) malloc (total * sizeof (BYTE))))
    {
      MESSAGE ('E', " Memory request failed.");
      goto the_end;
    }

  /* assign (DEFAULT) values */
  *out = (IMAGE *) ptr;
  (*out)->nbnd = nbnd;
  (*out)->nlin = nlin;
  (*out)->npix = npix;
  (*out)->nbit = SBIT;
/*  (*out)->gmin = undefined;  */
/*  (*out)->gmax = undefined;  */
  for (i = 0; i < TLEN; (*out)->text[i++] = '\0');
  (*out)->regions = NULL;
  (*out)->data = (PIXEL ***) (ptr + sizeof (IMAGE));

  /* initialize pointers */
  for (i = 0; i < nbnd; i++)
    {
      (*out)->data[i] =
        (PIXEL **) (ptr + sizeof (IMAGE) + nbnd * sizeof (PIXEL **) +
                    i * nlin * sizeof (PIXEL *));
      for (j = 0; j < nlin; j++)
        {
          (*out)->data[i][j] =
            (PIXEL *) (ptr + sizeof (IMAGE) + nbnd * sizeof (PIXEL **) +
                       nbnd * nlin * sizeof (PIXEL *) + (j * nbnd +
                                                         i) * npix *
                       sizeof (PIXEL));
        }
    }

  /* put new entry on the list */
  link = (list *) (ptr + total - sizeof (list));
  link->image = *out;
  link->next = img;
  img = link;

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function releases an image to free memory space.                    */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
RELIMG (out)
     IMAGE **out;               /* I/O  Address of the pointer to the image to be released.   */
/*----------------------------------------------------------------------------*/
{
  if (TIMES)
    TIMING (T_RELIMG);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "RELIMG");
    }

  /* check input */
  if (!CHECKIMG (*out))
    {
      MESSAGE ('E', " RELIMG: Can't identify image.");
      goto the_end;
    }

  /* release image */
  RELMEM (*out);
  *out = NULL;

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function releases an image and frees its data structure.  */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
RELMEM (in)
     IMAGE *in;                 /*  I   Pointer to the image to be released.                  */
/*----------------------------------------------------------------------------*/
{
  register list *ptr;
  ROIPtr r;

  if (TIMES)
    TIMING (T_RELMEM);

  /* take image off the list */
  if (img->image == in)
    {
      img = img->next;
    }
  else
    {
      for (ptr = img; ptr->next->image != in; ptr = ptr->next);
      ptr->next = ptr->next->next;
    }

  /* free allocated space */
  while ((r = in->regions) != NULL)
    {
      in->regions = r->next;
      free (r->name);
      r->name = NULL;

      free (r->zero);
      r->zero = NULL;

      free (r->gmin);
      r->gmin = NULL;

      free (r->gmax);
      r->gmax = NULL;

      free (r->mean);
      r->mean = NULL;

      free (r->dev);
      r->dev = NULL;

      free (r->cov);
      r->cov = NULL;

      free (r->cor);
      r->cor = NULL;

      free (r);
      r = NULL;
    }
  free (in);
  in = NULL;

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function determines whether or not an IMAGE pointer       */
/*   points to an image that was properly created by SADIE.                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short
CHECKIMG (in)
     IMAGE *in;                 /*  I   Pointer to the image to be checked.                   */
/*----------------------------------------------------------------------------*/
{
  list *ptr;

  if (TIMES)
    TIMING (T_CHECKIMG);

  /* check to see if image is on the list */
  for (ptr = img; ptr != NULL && ptr->image != in; ptr = ptr->next);

the_end:
  if (TIMES)
    TIMING (T_EXIT);
  return (ptr != NULL);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function finds the maximum and minimum graylevels         */
/*   in an image.                                                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
RANGE (in)
     IMAGE *in;                 /*  I   Pointer to the input image.                           */
/*----------------------------------------------------------------------------*/
{
  register PIXEL *p1, *p2, *p3, *gmin, *gmax;

  if (TIMES)
    TIMING (T_RANGE);

  /* find minimum and maximum */
  if (((long) in->nbnd * (long) in->nlin * (long) in->npix) % 2L == 0)
    {
      p1 = &in->data[0][0][0];
      p2 = &in->data[0][0][1];
    }
  else
    {
      p1 = &in->data[0][0][1];
      p2 = &in->data[0][0][2];
    }
  p3 = &(in->data[in->nbnd - 1][in->nlin - 1][in->npix - 1]);
  for (gmin = gmax = (&in->data[0][0][0]); p1 < p3; p1 += 2, p2 += 2)
    {
      if (*p1 < *p2)
        {
          if (*p1 < *gmin)
            gmin = p1;
          if (*p2 > *gmax)
            gmax = p2;
        }
      else
        {
          if (*p2 < *gmin)
            gmin = p2;
          if (*p1 > *gmax)
            gmax = p1;
        }
    }
  in->gmin = *gmin;
  in->gmax = *gmax;

  if (TIMES)
    TIMING (T_EXIT);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1995 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function swaps the bytes in a 2-byte word.                */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short
SWAP (unsigned char *cptr       /*  I  Pointer to the first byte of a 2-byte word.       */
/*----------------------------------------------------------------------------*/
  )
{
  unsigned char cval[2];

  if (TIMES)
    TIMING (T_SWAP);

  cval[0] = cptr[1];
  cval[1] = cptr[0];

the_end:
  if (TIMES)
    TIMING (T_EXIT);

  return (*(short *) cval);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1989 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function packs an array of pixels from PIXEL              */
/*   representation to "nbit" bits per pixel.                                 */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
PACK (short nbit,               /*  I   Number of bits/pixel.                                 */
      long npix,                /*  I   Number of pixels in the array.                        */
      PIXEL * line              /* I/O  Pointer to an array[npix] of pixels.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register BYTE *pckd = (BYTE *) line;
  register long i, j, k, l, m;
  unsigned long lpix;

  if (TIMES)
    TIMING (T_PACK);

  /* pack to nbit bits per pixel, in place */
  for (i = 0, j = (-1), l = m = SBPB; i < npix; i++)
    {
      for (lpix = (unsigned long) line[i], k = nbit; k > 0; m = k, k -= l)
        {
          l = m < l ? l - m : ((pckd[++j] = 0), SBPB);
          pckd[j] |=
            lpix << SBPB * sizeof (lpix) - k >> SBPB * sizeof (lpix) - l;
        }
    }

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

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1989 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function unpacks an array of pixels from "nbit"           */
/*   bits per pixel to PIXEL representation.                                  */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
UNPACK (short nbit,             /*  I   Number of bits/pixel.                                 */
        long npix,              /*  I   Number of pixels in the array.                        */
        PIXEL * line            /* I/O  Pointer to an array[npix] of pixels.                  */
/*----------------------------------------------------------------------------*/
  )
{
  register BYTE *pckd = (BYTE *) line;
  register long i, j, k, l, m;
  unsigned long lpix, mask =
    (unsigned long) ~0 >> sizeof (lpix) * SBPB - nbit;

  if (TIMES)
    TIMING (T_UNPACK);

  /* unpack from nbit bits per pixel, in place */
  for (i = npix - 1, j =
       (long) ceil ((double) (npix * nbit) / (double) SBPB) - 1, l =
       (npix * nbit) % SBPB ? (npix * nbit) % SBPB : SBPB, m = 0; i >= 0;
       line[i--] = (PIXEL) (lpix & mask))
    {
      for (lpix = 0, k = nbit; k > 0; m = k, k -= l)
        {
          l = m < l ? l - m : (--j, SBPB);
          lpix |= (unsigned long) pckd[j] >> SBPB - l << nbit - 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 low-level function extracts documentation from SADIE source code.   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
HELP (function, options)
     T_TIME function;           /*  I   Switch, indicating the desired function.              */
     char *options;             /*  I   is any combination of the following (as a string):    */
                /*      'B'     Background Information will be listed.        */
                /*      'C'     Copyright Information will be listed.         */
                /*      'G'     General Information will be listed.           */
                /*      'I'     Interface Information will be listed.         */
                /*      'P'     Programmer Information will be listed.        */
/*----------------------------------------------------------------------------*/
{
  register short i, j, k;
  char msg[SLEN], fname[SLEN];
  long last[SLEN], temp;
  FILE *fp;

  if (TIMES)
    TIMING (T_HELP);

  /* check input */
  if (T_EXIT > function || strlen (functions[function][1]) == 0
      || function > T_END)
    {
      MESSAGE ('E', " Can't find documentation.");
      goto the_end;
    }

  /* open documentation file */
  sprintf (fname, "%s%s", DIR, functions[function][1]);
  if (!(fp = fopen (fname, "r")))
    {
      sprintf (msg, " Can't open file %s.", fname);
      MESSAGE ('E', msg);
      goto the_end;
    }

  /* search file for requested documentation */
  for (i = 0; i < strlen (options); i++)
    {
      last[i] = -1L;
    }
  for (i = 1; fgets (msg, SLEN, fp); i++)
    {
      if (strncmp (msg, BEGIN, strlen (BEGIN)) == 0)
        {
          for (j = 0; j < strlen (options); j++)
            {
              if (msg[CODE] == options[j])
                {
                  if (last[j] > -1L)
                    {
                      for (k = 0; k < strlen (options); k++)
                        {
                          last[k] = -1L;
                        }
                    }
                  last[j] = ftell (fp) - (long) strlen (msg);
                }
            }
        }
      for (j = 0; j <= strlen (msg) - strlen (functions[function][0]); j++)
        {
          if (strncmp
              (msg + j, functions[function][0],
               strlen (functions[function][0])) == 0
              && msg[j + strlen (functions[function][0])] == ' ')
            goto sort;
        }
    }

sort:                          /* output */
  for (i = 0; i < strlen (options); i++)
    {
      for (j = i + 1; j < strlen (options); j++)
        {
          if (last[i] > last[j])
            {
              temp = last[i];
              last[i] = last[j];
              last[j] = temp;
            }
        }
    }

  /* output documentation */
  for (i = 0; i < strlen (options); i++)
    {
      if (last[i] > -1L)
        {
          fseek (fp, last[i], 0);
          fgets (msg, SLEN, fp);
          do
            {
              MESSAGE (' ', msg);
              fgets (msg, SLEN, fp);
            }
          while (strncmp (msg, END, strlen (END)));
          MESSAGE (' ', msg);
        }
    }

  /* close documentation file */
  if (fclose (fp))
    {
      sprintf (msg, " Can't close file %s.", fname);
      MESSAGE ('W', msg);
    }

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

---