---

Sadie_Geometry.c

Go to the documentation of this file.

/*
##########################################
# Sadie_Geometry.c -
#   Set of routines for linking SADIE geometry routines to tcl/tk.
#
# RCS: $Id: Sadie_Geometry.c,v 2.5 1999/02/01 21:44:15 gopalan Exp $ 
# 
# Digital Image Analysis Lab
# Dept. of Electrical and Computer Engineering
# University of Arizona
##########################################
*/

#include <tcl.h>
#include <tk.h>
#include <stdio.h>
#include <string.h>
#include "sadie.h"

/* RCS Indentification information */
static char rcsid[] =
  "$Id: Sadie_Geometry.c,v 2.5 1999/02/01 21:44:15 gopalan Exp $";

/*-------------------------------------------------------------*/
/* Global Sadie variables that must be set from within Tcl/Tk  */
/*-------------------------------------------------------------*/
extern short nlev;
extern short csize;
extern double weight;
extern double *count;
extern PIXEL gain;
extern PIXEL bias;
extern PIXEL gmin;
extern PIXEL gmax;
extern PIXEL thresh;
extern PIXEL gbrk[2][4];
extern PIXEL *table;

/* -------------------------------------------------------------------------- */

/* Global Variable to hold Polynomial Terms */
double xpolyterms[6] = { 0.0, 1.0, 0.0, 0.0, 0.0, 0.0 };
double ypolyterms[6] = { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0 };
int numpolyterms = 3;

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   RESAMPL from Tcl/Tk.  It expects a tcl global array                      */
/*   with these indices to exist:                                             */
/*      array(inimg,addr)         --  SADIE image address                     */
/*      array(lines)              --  int                                     */
/*      array(pix)                --  int                                     */
/*      array(incrlines)          --  int                                     */
/*      array(incrpix)            --  int                                     */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_AvgSubCmd (ClientData client_data, Tcl_Interp * interp,
                          int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr;
  IMAGE *inimg = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int lines, pix, incrlines, incrpix;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr);
      inimg = (IMAGE *) inimgaddr;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &lines) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &pix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(incrlines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("incrlines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &incrlines) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(incrpix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("incrpix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &incrpix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  RESAMPL (inimg, lines, pix, incrlines, incrpix, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   SUBSAMPL from Tcl/Tk.  It expects a tcl global array                     */
/*   with these indices to exist:                                             */
/*      array(inimg,addr)         --  SADIE image address                     */
/*      array(from,band)          --  int                                     */
/*      array(from,pix)           --  int                                     */
/*      array(from,line)          --  int                                     */
/*      array(to,band)            --  int                                     */
/*      array(to,pix)             --  int                                     */
/*      array(to,line)            --  int                                     */
/*      array(incr,band)          --  int                                     */
/*      array(incr,pix)           --  int                                     */
/*      array(incr,line)          --  int                                     */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_WinSubCmd (ClientData client_data, Tcl_Interp * interp,
                          int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr;
  IMAGE *inimg = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int fromband, frompix, fromline, toband, topix, toline, incrband, incrpix,
    incrline;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr);
      inimg = (IMAGE *) inimgaddr;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(from,band) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("from,band", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &fromband) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(from,pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("from,pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &frompix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(from,line) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("from,line", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &fromline) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(to,band) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("to,band", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &toband) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(to,pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("to,pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &topix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(to,line) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("to,line", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &toline) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(incr,band) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("incr,band", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &incrband) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(incr,pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("incr,pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &incrpix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(incr,line) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("incr,line", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &incrline) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  SUBSAMPL (inimg, fromband - 1, fromline - 1, frompix - 1, incrband,
            incrline, incrpix, ((toband - fromband) + 1),
            ((toline - fromline) + 1), ((topix - frompix) + 1), &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   EXPAND from Tcl/Tk.  It expects a tcl global array                       */
/*   with these indices to exist:                                             */
/*      array(inimg,addr)         --  SADIE image address                     */
/*      array(lines)              --  int                                     */
/*      array(pix)                --  int                                     */
/*      array(option)             --  int                                     */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_ScaleCmd (ClientData client_data, Tcl_Interp * interp,
                         int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr;
  IMAGE *inimg = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  double lines, pix, option;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr);
      inimg = (IMAGE *) inimgaddr;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &lines) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &pix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(option) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("option", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &option) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  EXPAND (inimg, lines, pix, option, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   ROTATE from Tcl/Tk.  It expects a tcl global array                       */
/*   with these indices to exist:                                             */
/*      array(inimg,addr)         --  SADIE image address                     */
/*      array(angle)              --  double                                  */
/*      array(option)             --  double                                  */
/*      array(graylevel)          --  PIXEL                                   */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_RotateCmd (ClientData client_data, Tcl_Interp * interp,
                          int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr;
  IMAGE *inimg = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  double angle, option;
  PIXEL graylevel;
  double tempdouble;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr);
      inimg = (IMAGE *) inimgaddr;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input double array(angle) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("angle", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &angle) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input double array(option) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("option", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &option) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input PIXEL array(graylevel) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("graylevel", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &tempdouble) == TCL_ERROR)
        return TCL_ERROR;
      graylevel = (PIXEL) tempdouble;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  ROTATE (inimg, angle, graylevel, option, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   TRNSFORM from Tcl/Tk.  It expects a tcl global array                     */
/*   with these indices to exist:                                             */
/*      array(inimg,addr)         --  SADIE image address                     */
/*      array(option)             --  int                                     */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_MirrorCmd (ClientData client_data, Tcl_Interp * interp,
                          int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr;
  IMAGE *inimg = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int option;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr);
      inimg = (IMAGE *) inimgaddr;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(option) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("option", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &option) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  TRNSFORM (inimg, option, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   GEOMCOEF from Tcl/Tk.  It expects a tcl global array                     */
/*   with these indices to exist:                                             */
/*       array(pointcount)                                                    */
/*       array(termcount)                                                     */
/*       array(trans,x,1-6)                                                   */
/*       array(trans,y,1-6)                                                   */
/*       array(ref,x,1-6)                                                     */
/*       array(ref,y,1-6)                                                     */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_ContPtsCmd (ClientData client_data, Tcl_Interp * interp,
                           int argc, char *argv[])
{
  char *tclvar;
  int npts, nterms;
  double transx[6], transy[6], refx[6], refy[6];
  char index[50], *var = NULL;
  int i;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  var = argv[1];

  if (!
      (tclvar =
       Tcl_GetVar2 (interp, var, "pointcount",
                    TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)))
    {
      return TCL_ERROR;
    }
  if (Tcl_GetInt (interp, tclvar, &npts) != TCL_OK)
    {
      return TCL_ERROR;
    }

  if (!
      (tclvar =
       Tcl_GetVar2 (interp, var, "termcount",
                    TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)))
    {
      return TCL_ERROR;
    }
  if (Tcl_GetInt (interp, tclvar, &nterms) != TCL_OK)
    {
      return TCL_ERROR;
    }

  for (i = 0; i < 6; i++)
    {
      /* Get the transformation image x-control points */
      sprintf (index, "trans,x,%d", i + 1);
      if (!
          (tclvar =
           Tcl_GetVar2 (interp, var, index,
                        TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)))
        {
          return TCL_ERROR;
        }
      if (Tcl_GetDouble (interp, tclvar, &transx[i]) != TCL_OK)
        {
          return TCL_ERROR;
        }

      /* Get the transformation image y-control points */
      sprintf (index, "trans,y,%d", i + 1);
      if (!
          (tclvar =
           Tcl_GetVar2 (interp, var, index,
                        TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)))
        {
          return TCL_ERROR;
        }
      if (Tcl_GetDouble (interp, tclvar, &transy[i]) != TCL_OK)
        {
          return TCL_ERROR;
        }

      /* Get the reference image x-control points */
      sprintf (index, "ref,x,%d", i + 1);
      if (!
          (tclvar =
           Tcl_GetVar2 (interp, var, index,
                        TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)))
        {
          return TCL_ERROR;
        }
      if (Tcl_GetDouble (interp, tclvar, &refx[i]) != TCL_OK)
        {
          return TCL_ERROR;
        }

      /* Get the reference image y-control points */
      sprintf (index, "ref,y,%d", i + 1);
      if (!
          (tclvar =
           Tcl_GetVar2 (interp, var, index,
                        TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)))
        {
          return TCL_ERROR;
        }
      if (Tcl_GetDouble (interp, tclvar, &refy[i]) != TCL_OK)
        {
          return TCL_ERROR;
        }

    }

  GEOMCOEF ((double *) transx, (double *) transy, (double *) refx,
            (double *) refy, (short) npts, (short) nterms,
            (double *) xpolyterms, (double *) ypolyterms);
  numpolyterms = nterms;

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   GEOMWARP from Tcl/Tk.  It expects a tcl global array                     */
/*   with these indices to exist:                                             */
/*      array(inimg,addr)         --  SADIE image address                     */
/*      array(lines)              --  int                                     */
/*      array(pix)                --  int                                     */
/*      array(option)             --  double                                  */
/*      array(graylevel)          --  PIXEL                                   */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_GeomWarpCmd (ClientData client_data, Tcl_Interp * interp,
                            int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr;
  IMAGE *inimg = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int lines, pix;
  double option;
  PIXEL graylevel;
  double tempdouble;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr);
      inimg = (IMAGE *) inimgaddr;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &lines) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &pix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input double array(option) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("option", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &option) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input PIXEL array(graylevel) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("graylevel", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &tempdouble) == TCL_ERROR)
        return TCL_ERROR;
      graylevel = (PIXEL) tempdouble;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  GEOMWARP (inimg, inimg->nbnd, (short) lines, (short) pix,
            (double *) xpolyterms, (double *) ypolyterms,
            (short) numpolyterms, option, graylevel, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   HMOSAIC from Tcl/Tk.  It expects a tcl global array                      */
/*   with these indices to exist:                                             */
/*      array(inimg,addr1)        --  SADIE image address                     */
/*      array(inimg,addr2)        --  SADIE image address                     */
/*      array(offset)             --  int                                     */
/*      array(fill)               --  PIXEL                                   */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_HMosaicCmd (ClientData client_data, Tcl_Interp * interp,
                           int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr1, inimgaddr2;
  IMAGE *inimg1 = NULL, *inimg2 = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int offset;
  PIXEL fill;
  double tempdouble;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr1) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr1", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr1);
      inimg1 = (IMAGE *) inimgaddr1;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read input image array(inimg,addr2) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr2", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr2);
      inimg2 = (IMAGE *) inimgaddr2;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &offset) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input PIXEL array(fill) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("fill", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &tempdouble) == TCL_ERROR)
        return TCL_ERROR;
      fill = (PIXEL) tempdouble;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  HMOSAIC (inimg1, inimg2, offset, fill, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   VMOSAIC from Tcl/Tk.  It expects a tcl global array                      */
/*   with these indices to exist:                                             */
/*      array(inimg,addr1)        --  SADIE image address                     */
/*      array(inimg,addr2)        --  SADIE image address                     */
/*      array(offset)             --  int                                     */
/*      array(fill)               --  PIXEL                                   */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_VMosaicCmd (ClientData client_data, Tcl_Interp * interp,
                           int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr1, inimgaddr2;
  IMAGE *inimg1 = NULL, *inimg2 = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int offset;
  PIXEL fill;
  double tempdouble;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr1) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr1", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr1);
      inimg1 = (IMAGE *) inimgaddr1;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read input image array(inimg,addr2) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr2", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr2);
      inimg2 = (IMAGE *) inimgaddr2;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &offset) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input PIXEL array(fill) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("fill", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &tempdouble) == TCL_ERROR)
        return TCL_ERROR;
      fill = (PIXEL) tempdouble;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  VMOSAIC (inimg1, inimg2, offset, fill, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   MOSAIC from Tcl/Tk.  It expects a tcl global array                       */
/*   with these indices to exist:                                             */
/*      array(lines)              --  int                                     */
/*      array(pix)                --  int                                     */
/*      array(fill)               --  PIXEL                                   */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_GenMosaicCmd (ClientData client_data, Tcl_Interp * interp,
                             int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr[2];
  IMAGE *inimg[2];
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  short offsetlines[2], offsetpix[2];
  int lines, pix, tempint;
  PIXEL fill;
  double tempdouble;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr1) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr1", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr[0]);
      inimg[0] = (IMAGE *) inimgaddr[0];
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read input image array(inimg,addr2) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr2", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr[1]);
      inimg[1] = (IMAGE *) inimgaddr[1];
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &lines) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &pix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset1,lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset1,lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &tempint) == TCL_ERROR)
        return TCL_ERROR;
      offsetlines[0] = (short) tempint;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset2,lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset2,lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &tempint) == TCL_ERROR)
        return TCL_ERROR;
      offsetlines[1] = (short) tempint;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset1,pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset1,pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &tempint) == TCL_ERROR)
        return TCL_ERROR;
      offsetpix[0] = (short) tempint;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset2,pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset2,pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &tempint) == TCL_ERROR)
        return TCL_ERROR;
      offsetpix[1] = (short) tempint;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input PIXEL array(fill) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("fill", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetDoubleFromObj (interp, tclobj, &tempdouble) == TCL_ERROR)
        return TCL_ERROR;
      fill = (PIXEL) tempdouble;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  MOSAIC (inimg, 2, lines, pix, offsetlines, offsetpix, fill, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure provides an interface to the SADIE function               */
/*   INSERT from Tcl/Tk.  It expects a tcl global array                       */
/*   with these indices to exist:                                             */
/*      array(inimg,addr1)        --  SADIE image address                     */
/*      array(inimg,addr2)        --  SADIE image address                     */
/*      array(offset,lines)       --  int                                     */
/*      array(offset,pix)         --  int                                     */
/*      array(outname)            --  char*                                   */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_InsertCmd (ClientData client_data, Tcl_Interp * interp,
                          int argc, char *argv[])
{
  Tcl_Obj *tclobj = NULL;
  char msg[SLEN];
  char *array = NULL;
  char *tempstr = NULL;
  int strlen;
  int inimgaddr1, inimgaddr2;
  IMAGE *inimg1 = NULL, *inimg2 = NULL;
  int outimgaddr;
  IMAGE *outimg = NULL;
  char *outname = NULL;
  int offsetlines, offsetpix;

  if (argc != 2)
    {
      Tcl_AppendResult (interp, "wrong # args: should be \"",
                        argv[0], " arrayname\"", (char *) NULL);
      return TCL_ERROR;
    }
  array = argv[1];

  /* Read input image array(inimg,addr1) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr1", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr1);
      inimg1 = (IMAGE *) inimgaddr1;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read input image array(inimg,addr2) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("inimg,addr2", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      tempstr = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
      sscanf (tempstr, "%x", &inimgaddr2);
      inimg2 = (IMAGE *) inimgaddr2;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset,lines) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset,lines", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &offsetlines) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the input integer array(offset,pix) */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("offset,pix", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      if (Tcl_GetIntFromObj (interp, tclobj, &offsetpix) == TCL_ERROR)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  /* Read the output image 1 name */
  if (tclobj =
      Tcl_ObjGetVar2 (interp, Tcl_NewStringObj (array, -1),
                      Tcl_NewStringObj ("outname", -1),
                      TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG))
    {
      outname = Tcl_GetStringFromObj (tclobj, &strlen);
      if (strlen <= 0)
        return TCL_ERROR;
    }
  else
    {
      return TCL_ERROR;
    }

  INSERT (inimg1, inimg2, offsetlines, offsetpix, &outimg);

  if (CHECKIMG (outimg))
    sprintf (outimg->text, "%s", outname);
  outimgaddr = (int) outimg;

  sprintf (msg, "%x", outimgaddr);
  Tcl_SetResult (interp, msg, TCL_VOLATILE);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure initializes the all of the procedures                     */
/*   in this file by registering them with Tcl.                               */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
int
Sadie_Geometry_Init (Tcl_Interp * interp)
{
  Tcl_CreateCommand (interp, "Sadie_Geometry_AvgSub",
                     Sadie_Geometry_AvgSubCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_WinSub",
                     Sadie_Geometry_WinSubCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_Scale", Sadie_Geometry_ScaleCmd,
                     (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_Rotate",
                     Sadie_Geometry_RotateCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_Mirror",
                     Sadie_Geometry_MirrorCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_ContPts",
                     Sadie_Geometry_ContPtsCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_GeomWarp",
                     Sadie_Geometry_GeomWarpCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_HMosaic",
                     Sadie_Geometry_HMosaicCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_VMosaic",
                     Sadie_Geometry_VMosaicCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_GenMosaic",
                     Sadie_Geometry_GenMosaicCmd, (ClientData) NULL, NULL);
  Tcl_CreateCommand (interp, "Sadie_Geometry_Insert",
                     Sadie_Geometry_InsertCmd, (ClientData) NULL, NULL);

  return TCL_OK;
}

---