---

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;
}

---