---

Sadie_Image.c

Go to the documentation of this file.

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*-General Information--------------------------------------------------------*/
/*                                                                            */

/*   This function reads a SADIE image from disk into main memory.  A photo   */
/*   image  string  handler for  SADIE  image  strings.   This function  is   */
/*   modeled after  the file tkImgPPM.c  which is contained in  the generic   */
/*   directory of the Tk source distribution.                                 */
/*                                                                            */

/*   Rather than taking  an image file name or pixel  data string as input,   */
/*   the memory address of a SADIE image that is already loaded into memory   */
/*   is passed  in through the string  interface. This is  using the string   */
/*   interface  in a  way other  than it  was intended,  but it  provides a   */
/*   convenient interface none the less.                                      */
/*                                                                            */
/*----------------------------------------------------------------------------*/

#define  USE_OLD_IMAGE

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

/* The format record for the SADIE string format: */
static int MatchSADIE _ANSI_ARGS_ ((char *string,
                                    char *formatString,
                                    int *widthPtr, int *heightPtr));

static int ReadSADIE _ANSI_ARGS_ ((Tcl_Interp * interp,
                                   char *string,
                                   char *formatString,
                                   Tk_PhotoHandle imageHandle,
                                   int destX, int destY,
                                   int width, int height,
                                   int srcX, int srcY));

static int WriteSADIE _ANSI_ARGS_ ((Tcl_Interp * interp,
                                    char *ImgName,
                                    char *formatString,
                                    Tk_PhotoImageBlock * blockPtr));

Tk_PhotoImageFormat tkImgFmtSADIE = {
  "SADIE",                      /* Name of the image format */
  NULL,                         /* File match procedure     */
  MatchSADIE,                   /* String match procedure   */
  NULL,                         /* File read procedure      */
  ReadSADIE,                    /* String read procedure    */
  WriteSADIE,                   /* File write procedure     */
  NULL,                         /* String write procedure   */
};

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*-General Information--------------------------------------------------------*/
/* MatchSADIE -                                                               */
/*                                                                            */
/*   This procedure is  invoked by the photo image type  to see if image      */
/*   data is in SADIE format.                                                 */
/*                                                                            */
/* Results:                                                                   */
/*   The return value  is >0 if the first  characters in string "string"      */
/*   look like SADIE data, and 0 otherwise.                                   */
/*                                                                            */
/* Side effects:                                                              */
/*   The access position in file may change.                                  */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
static int
MatchSADIE (char *string,       /*  I   The string, open for reading.                 */
            char *formatString, /*  I   User-specified format string, or NULL.        */
            int *widthPtr,      /*  O   The dimensions of the image are returned here */
            int *heightPtr      /*  O   if the string is a valid raw SADIE string.    */
/*----------------------------------------------------------------------------*/
  )
{
  int imgaddr;
  IMAGE *img;

  sscanf (string, "%x", &imgaddr);
  img = (IMAGE *) imgaddr;

  if (CHECKIMG (img))
    {
      *widthPtr = img->npix;
      *heightPtr = img->nlin;
      return (1);
    }
  else
    return (0);
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*-General Information--------------------------------------------------------*/
/* ReadSADIE -                                                               */
/*                                                                            */
/*   This procedure is called by the  photo image type to read SADIE format   */
/*   data from a string and write it into a given photo image.                */
/*                                                                            */
/* Results:                                                                   */
/*   A standard TCL completion code. If TCL_ERROR is returned then an error   */
/*   message is left in interp->result.                                       */
/*                                                                            */
/* Side effects:                                                              */
/*   The access  position in  string "string" is  changed, and new  data is   */
/*   added to the image given by imageHandle.                                 */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
static int
ReadSADIE (Tcl_Interp * interp, /*  I   Interpreter to use for reporting errors.  */
           char *string,        /*  I   The image string, open for reading.       */
           char *formatString,  /*  I   User-specified format string, or NULL.    */
           Tk_PhotoHandle imageHandle,  /*  I   The photo image to write into.            */
           int destX,           /*  I   Coordinates of top-left pixel in          */
           int destY,           /*         photo image to be written to.          */
           int width,           /*  I   Dimensions of block of photo image to     */
           int height,          /*         be written to.                         */
           int srcX,            /*  I   Coordinates of top-left pixel to be used  */
           int srcY             /*         in image being read.                   */
/*----------------------------------------------------------------------------*/
  )
{
  int nLines, nBytes, h, type, count;
  unsigned char *pixelPtr;
  int j, k;
  int stretchmin = DMIN;        /* Linear stretch minimum value, used for displayed image */
  int stretchmax = DMAX;        /* Linear stretch maximum value, used for displayed image */
  int stretchMin = 0;
  int stretchMax = 255;
  double offset, factor;
  int imgaddr;
  int option;
  int var_exists;
  Tk_PhotoImageBlock block;
  IMAGE *img;
  BYTE pixel;

  Tcl_Eval (interp, "info exists SadieVar(getstretched)");
  Tcl_GetIntFromObj (interp, Tcl_GetObjResult (interp), &var_exists);
  if (var_exists)
    {
      Tcl_GetInt (interp,
                  Tcl_GetVar2 (interp, "SadieVar", "getstretched",
                               TCL_GLOBAL_ONLY), &option);
    }
  else
    {
      option = 1;
    }

  sscanf (string, "%x", &imgaddr);
  img = (IMAGE *) imgaddr;

  if (!CHECKIMG (img))
    {
      Tcl_AppendResult (interp,
                        "Couldn't identify SADIE image from input string.",
                        NULL);
      return TCL_ERROR;
    }
  if ((img->nbnd < 1))
    {
      Tcl_AppendResult (interp, "Image bands not within display range.",
                        NULL);
      return TCL_ERROR;
    }
  if (img->nlin <= 0)
    {
      Tcl_AppendResult (interp, "Image lines not within display range.",
                        NULL);
      return TCL_ERROR;
    }
  if (img->npix <= 0)
    {
      Tcl_AppendResult (interp, "Image pixels not within display range.",
                        NULL);
      return TCL_ERROR;
    }

  if (width > img->npix)
    {
      width = img->npix;
    }
  if (height > img->nlin)
    {
      height = img->nlin;
    }
  if ((width <= 0) || (height <= 0))
    {
      return TCL_OK;
    }

  if (img->nbnd != 3)
    {                           /* Grayscale image */
      block.pixelSize = 1;
      block.offset[0] = 0;
      block.offset[1] = 0;
      block.offset[2] = 0;
    }
  else
    {                           /* RGB image */
      block.pixelSize = 3;
      block.offset[0] = 0;
      block.offset[1] = 1;
      block.offset[2] = 2;
    }

  block.width = width;
  block.pitch = block.pixelSize * img->npix;

  Tk_PhotoExpand (imageHandle, destX + width, destY + height);

  nLines = height;
  if (nLines <= 0)
    {
      nLines = 1;
    }

  nBytes = nLines * block.pitch;

  pixelPtr = (unsigned char *) ckalloc ((unsigned) nBytes);
  block.pixelPtr = pixelPtr;

  RANGE (img);

  if (block.pixelSize == 1)
    {
      if (option == 1)
        {                       /* Stretch the image */

          if ((PIXEL) stretchMin == img->gmin
              && img->gmax == (PIXEL) stretchMax)
            {
              for (j = 0; j < img->nlin; j++)
                {
                  for (k = 0; k < img->npix; k++)
                    {
                      pixel = (BYTE) img->data[0][j][k];
                      *pixelPtr++ = pixel;
                    }
                }
            }
          else if (img->gmin < img->gmax)
            {
              factor =
                (double) (stretchMax - stretchMin) / (double) (img->gmax -
                                                               img->gmin);
              offset = (double) (stretchMin) - (double) (img->gmin) * factor;

              for (j = 0; j < img->nlin; j++)
                {
                  for (k = 0; k < img->npix; k++)
                    {
                      pixel =
                        (BYTE) ((double) (img->data[0][j][k]) * factor +
                                offset);
                      *pixelPtr++ = pixel;
                    }
                }
            }
          else
            {                   /* (img->gmin == img->gmax) */
              factor =
                (double) (stretchMax - stretchMin) / (double) (SMAX - SMIN);
              pixel =
                (BYTE) ((double)
                        (min (max (SMIN, img->data[0][0][0]), SMAX) -
                         SMIN) * factor + (double) stretchMin);

              for (j = 0; j < img->nlin; j++)
                {
                  for (k = 0; k < img->npix; k++)
                    {
                      *pixelPtr++ = pixel;
                    }
                }
            }
        }
      else
        {                       /* Don't stretch the image */

          for (j = 0; j < img->nlin; j++)
            {
              for (k = 0; k < img->npix; k++)
                {
                  pixel = (BYTE) img->data[0][j][k];
                  *pixelPtr++ = pixel;
                }
            }
        }

      block.height = height;
      Tk_PhotoPutBlock (imageHandle, &block, destX, destY, width, height);

    }
  else if (block.pixelSize == 3)
    {
      if (option == 1)
        {                       /* Stretch the image */

          if ((PIXEL) stretchMin == img->gmin
              && img->gmax == (PIXEL) stretchMax)
            {
              for (j = 0; j < img->nlin; j++)
                {
                  for (k = 0; k < img->npix; k++)
                    {
                      pixel = (BYTE) img->data[0][j][k];
                      *pixelPtr++ = pixel;
                      pixel = (BYTE) img->data[1][j][k];
                      *pixelPtr++ = pixel;
                      pixel = (BYTE) img->data[2][j][k];
                      *pixelPtr++ = pixel;
                    }
                }
            }
          else if (img->gmin < img->gmax)
            {
              factor =
                (double) (stretchMax - stretchMin) / (double) (img->gmax -
                                                               img->gmin);
              offset = (double) (stretchMin) - (double) (img->gmin) * factor;

              for (j = 0; j < img->nlin; j++)
                {
                  for (k = 0; k < img->npix; k++)
                    {
                      pixel =
                        (BYTE) ((double) (img->data[0][j][k]) * factor +
                                offset);
                      *pixelPtr++ = pixel;
                      pixel =
                        (BYTE) ((double) (img->data[1][j][k]) * factor +
                                offset);
                      *pixelPtr++ = pixel;
                      pixel =
                        (BYTE) ((double) (img->data[2][j][k]) * factor +
                                offset);
                      *pixelPtr++ = pixel;
                    }
                }
            }
          else
            {                   /* (img->gmin == img->gmax) */

              factor =
                (double) (stretchMax - stretchMin) / (double) (SMAX - SMIN);
              pixel =
                (BYTE) ((double)
                        (min (max (SMIN, img->data[0][0][0]), SMAX) -
                         SMIN) * factor + (double) stretchMin);

              for (j = 0; j < img->nlin; j++)
                {
                  for (k = 0; k < img->npix; k++)
                    {
                      *pixelPtr++ = pixel;
                      *pixelPtr++ = pixel;
                      *pixelPtr++ = pixel;
                    }
                }
            }
        }
      else
        {                       /* Don't stretch the image */

          for (j = 0; j < img->nlin; j++)
            {
              for (k = 0; k < img->npix; k++)
                {
                  pixel = (BYTE) img->data[0][j][k];
                  *pixelPtr++ = pixel;
                  pixel = (BYTE) img->data[1][j][k];
                  *pixelPtr++ = pixel;
                  pixel = (BYTE) img->data[2][j][k];
                  *pixelPtr++ = pixel;
                }
            }
        }

      block.height = height;
      Tk_PhotoPutBlock (imageHandle, &block, destX, destY, width, height);

    }
  else
    printf ("tkImgSADIE does not support a pixel size of: %d \n",
            block.pixelSize);

  return TCL_OK;
}

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1988 by the University of Arizona Digital Image Analysis Lab */
/*-General Information--------------------------------------------------------*/
/* WriteSADIE -                                                               */
/*                                                                            */
/*   This procedure  is called  by the  photo image type  to write  a photo   */
/*   image to a SADIE image.                                                  */
/*                                                                            */
/* Results:                                                                   */
/*   A  standard TCL  completion code.   If TCL_ERROR  is returned  then an   */
/*   error message is left in interp->result.                                 */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
static int
WriteSADIE (Tcl_Interp * interp,        /*  I   Interpreter to use for reporting errors. */
            char *ImgName,      /*  I   The address of image to write to.        */
            char *formatString, /*  I   User-specified format string, or NULL.   */
            Tk_PhotoImageBlock * blockPtr       /*  I   pointer to photo image data.             */
  )
{
  char msg[SLEN];
  unsigned char *pixelPtr, *pixLinePtr;
  int w, h;
  int greenOffset, blueOffset, nBytes;
  int addrstr;
  int pixint;
  IMAGE *img;
  PIXEL pixflt;

  /* create image of appropriate size */
  if (!CHECKIMG (img))
    GETMEM (3, blockPtr->height, blockPtr->width, &img);
  if (!img)
    return TCL_ERROR;

  pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0];
  greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
  blueOffset = blockPtr->offset[2] - blockPtr->offset[0];

/*    if ((greenOffset == 1) && (blueOffset == 2) && (blockPtr->pixelSize == 3)
        && (blockPtr->pitch == (blockPtr->width * 3))) { */
  if (greenOffset == 1 && blueOffset == 2 && blockPtr->pixelSize == 4
      && blockPtr->pitch == (blockPtr->width * 4))
    {
      pixelPtr = pixLinePtr;

      for (h = 0; h < blockPtr->height; h++)
        {
          for (w = 0; w < blockPtr->width; w++)
            {
              pixint = *pixelPtr;
              pixflt = (PIXEL) pixint;
              img->data[0][h][w] = pixflt;

              pixelPtr++;
              pixint = *pixelPtr;
              pixflt = (PIXEL) pixint;
              img->data[1][h][w] = pixflt;

              pixelPtr++;
              pixint = *pixelPtr;
              pixflt = (PIXEL) pixint;
              img->data[2][h][w] = pixflt;
              pixelPtr += 2;
            }
        }

      if (NAMES)
        {
          MESSAGE ('I', "");
          MESSAGE ('I', "TKIMGSADIE");
          MESSAGE ('I', "");
          sprintf (msg, " Input file:                                 %s",
                   ImgName);
          MESSAGE ('I', msg);
          sprintf (msg,
                   " Number of bands, lines, pixels:             %d, %d, %d",
                   img->nbnd, img->nlin, img->npix);
          MESSAGE ('I', msg);
          sprintf (msg, " Number of bits/pixel/band:                  %d", 8);
          MESSAGE ('I', msg);
          sprintf (msg,
                   " Graylevel minimum, maximum:                 %10.4e, %10.4e",
                   img->gmin, img->gmax);
          MESSAGE ('I', msg);
          MESSAGE ('I', " ...............");
        }

      addrstr = (int) img;

      sprintf (img->text, "%s", ImgName);
      sprintf (msg, "%x", addrstr);
      Tcl_SetResult (interp, msg, TCL_VOLATILE);

      return TCL_OK;
    }
  else if (blockPtr->pixelSize == 1)
    {                           /* If Grayscale image */

      img->nbnd = 1;
      img->npix = blockPtr->width;
      img->nlin = blockPtr->height;
      img->nbit = 32;

      pixelPtr = pixLinePtr;

      for (h = 0; h < blockPtr->height; h++)
        {
          for (w = 0; w < blockPtr->width; w++)
            {
              img->data[0][h][w] = (PIXEL) pixelPtr[0];
              pixelPtr++;
            }
        }

      if (NAMES)
        {
          MESSAGE ('I', "");
          MESSAGE ('I', "TKIMGSADIE");
          MESSAGE ('I', "");
          sprintf (msg, " Input file:                                 %s",
                   ImgName);
          MESSAGE ('I', msg);
          sprintf (msg,
                   " Number of bands, lines, pixels:             %d, %d, %d",
                   img->nbnd, img->nlin, img->npix);
          MESSAGE ('I', msg);
          sprintf (msg, " Number of bits/pixel/band:                  %d", 8);
          MESSAGE ('I', msg);
          sprintf (msg,
                   " Graylevel minimum, maximum:                 %10.4e, %10.4e",
                   img->gmin, img->gmax);
          MESSAGE ('I', msg);
          MESSAGE ('I', " ...............");
        }

      addrstr = (int) img;

      sprintf (img->text, "%s", ImgName);
      sprintf (msg, "%x", addrstr);
      Tcl_SetResult (interp, msg, TCL_VOLATILE);

      return TCL_OK;
    }
  else
    return TCL_ERROR;

}

int
Sadie_Image_Init (Tcl_Interp * interp)
{

  Tk_CreatePhotoImageFormat (&tkImgFmtSADIE);

  return TCL_OK;
}

---