---

pnm2img.c

Go to the documentation of this file.

#include "sadie.h"

#define BUFFER_SIZE 1000

#define UCHAR(c) ((unsigned char) (c))

/*
 * The maximum amount of memory to allocate for data read from the
 * file.  If we need more than this, we do it in pieces.
 */

#define MAX_MEMORY      10000   /* don't allocate > 10KB */

/*
 * Define PGM and PNM, i.e. gray images and color images.
 */

#define PGM 1
#define PPM 2

/*
 * Prototypes for local procedures defined in this file:
 */

static int ReadPNMFileHeader (FILE * fp,
                              int *widthPtr, int *heightPtr,
                              int *maxIntensityPtr);

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1998 by the University of Arizona Digital Image Analysis Lab */
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function reads a PNM image from disk into main memory.            */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
PNM2IMG (name, out)
     char *name;                /*  I   String, containing the name of the disk file.         */
     IMAGE **out;               /*  O   Address of a pointer to the image.                    */
/*----------------------------------------------------------------------------*/
{
  int i, j, k;
  char msg[SLEN];
  int fileWidth, fileHeight, maxIntensity;
  int nLines, nBytes, h, type, count;
  FILE *fp = NULL;
  unsigned char *pixelPtr = NULL, *data = NULL;

  /* open image file */
  if (!(fp = fopen (name, "r")))
    {
      sprintf (msg, " Can't open file %s.", name);
      MESSAGE ('E', msg);
      goto the_end;
    }

  type = ReadPNMFileHeader (fp, &fileWidth, &fileHeight, &maxIntensity);
  if (type == 0)
    {
      sprintf (msg, "Couldn't read raw PNM header from file %s.", name);
    }
  if ((fileWidth <= 0) || (fileHeight <= 0))
    {
      sprintf (msg, "PNM image file %s has dimension(s) <= 0", name);
      MESSAGE ('E', msg);
      goto the_end;
    }
  if ((maxIntensity <= 0) || (maxIntensity >= 256))
    {
      sprintf (msg, "PNM image file %s has bad maximum intensity value %d",
               name, maxIntensity);
      MESSAGE ('E', msg);
      goto the_end;
    }

  if (type == PGM)
    {
      /* create image of appropriate size */
      if (!CHECKIMG (*out))
        GETMEM (1, fileHeight, fileWidth, out);
      if (!CHECKIMG (*out))
        {
          sprintf (msg, "Can't allocate memory for image.");
          MESSAGE ('E', msg);
          goto the_end;
        }
    }
  else
    {
      /* create image of appropriate size */
      if (!CHECKIMG (*out))
        GETMEM (3, fileHeight, fileWidth, out);
      if (!CHECKIMG (*out))
        {
          sprintf (msg, "Can't allocate memory for image.");
          MESSAGE ('E', msg);
          goto the_end;
        }
    }

  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "PNM2IMG");
      MESSAGE ('I', "");
      sprintf (msg, " Input file:                                 %s", name);
      MESSAGE ('I', msg);
      MESSAGE ('I', " Input format:                               PNM");
      sprintf (msg, " Number of bands, lines, pixels:             %d, %d, %d",
               (*out)->nbnd, (*out)->nlin, (*out)->npix);
      MESSAGE ('I', msg);
      sprintf (msg, " Number of bits/pixel/band:                  %d", 8);
      MESSAGE ('I', msg);
      MESSAGE ('I', " ...............");
    }

  nBytes = (*out)->npix * (*out)->nbnd;
  pixelPtr = (unsigned char *) malloc ((unsigned) nBytes);
  if (!pixelPtr)
    {
      MESSAGE ('E', "Could not allocate memory to read image.");
      goto the_end;
    }

  for (j = 0; j < (*out)->nlin; j++)
    {
      data = pixelPtr;
      count = fread (data, 1, nBytes, fp);

      if (count != nBytes)
        {
          sprintf (msg, "Error reading PNM image file %s: not enough data",
                   name);
          MESSAGE ('E', msg);
          goto the_end;
        }
      for (k = 0; k < (*out)->npix; k++)
        {
          for (i = 0; i < (*out)->nbnd; i++)
            {
              (*out)->data[i][j][k] = (PIXEL) * data++;
            }
        }
    }

the_end:

  if (pixelPtr)
    free (pixelPtr);

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

static int
ReadPNMFileHeader (fp, widthPtr, heightPtr, maxIntensityPtr)
     FILE *fp;                  /* Image file to read the header from */
     int *widthPtr, *heightPtr; /* The dimensions of the image are
                                 * returned here. */
     int *maxIntensityPtr;      /* The maximum intensity value for
                                 * the image is stored here. */
{
  char buffer[BUFFER_SIZE];
  int i, numFields, firstInLine;
  int type = 0;
  char c;

  /*
   * Read 4 space-separated fields from the file, ignoring
   * comments (any line that starts with "#").
   */

  if (fread (&c, 1, 1, fp) != 1)
    {
      return 0;
    }
  firstInLine = 1;
  i = 0;
  for (numFields = 0; numFields < 4; numFields++)
    {
      /*
       * Skip comments and white space.
       */

      while (1)
        {
          while (isspace (UCHAR (c)))
            {
              firstInLine = (c == '\n');
              if (fread (&c, 1, 1, fp) != 1)
                {
                  return 0;
                }
            }
          if (c != '#')
            {
              break;
            }
          do
            {
              if (fread (&c, 1, 1, fp) != 1)
                {
                  return 0;
                }
            }
          while (c != '\n');
          firstInLine = 1;
        }

      /*
       * Read a field (everything up to the next white space).
       */

      while (!isspace (UCHAR (c)))
        {
          if (i < (BUFFER_SIZE - 2))
            {
              buffer[i] = c;
              i++;
            }
          if (fread (&c, 1, 1, fp) != 1)
            {
              goto done;
            }
        }
      if (i < (BUFFER_SIZE - 1))
        {
          buffer[i] = ' ';
          i++;
        }
      firstInLine = 0;
    }
done:
  buffer[i] = 0;

  /*
   * Parse the fields, which are: id, width, height, maxIntensity.
   */

  if (strncmp (buffer, "P6 ", 3) == 0)
    {
      type = PPM;
    }
  else if (strncmp (buffer, "P5 ", 3) == 0)
    {
      type = PGM;
    }
  else
    {
      return 0;
    }
  if (sscanf (buffer + 3, "%d %d %d", widthPtr, heightPtr, maxIntensityPtr)
      != 3)
    {
      return 0;
    }
  return type;
}

---