image.c

Hausdorff Distance for Image Recognition

	return(0);
	}
    }

/*
 * Take the comment which was accumulated from the input file, copy it
 * and tack it into this header.
 */
static boolean
setComment(ImageHeader *header)
{
    assert(header != (ImageHeader *)NULL);
		      
    if (incommentsize == 0) {
	/* There was no comment in the input file */
	header->comment = (char *)NULL;
	return(TRUE);
	}

    /* The last thing in the comment should be a newline - clobber it */
    assert(incomment[incommentsize - 1] == '\n');
    incomment[incommentsize] = '\0';
    header->comment = strdup(incomment);
    if (header->comment == (char *)NULL) {
	return(FALSE);
	}
    return(TRUE);
    }

void *
imNew(ImageType type, unsigned width, unsigned height)
{
    return(imNewOffset(type, width, height, 0, 0));
    }

void *
imNewOffset(ImageType type, unsigned width, unsigned height,
	    int xbase, int ybase)
{
    void **areaPtr;
    ImageHeader *newHeader;

    /* Allocate and initialise the header */
    newHeader = (ImageHeader *)malloc(sizeof(* newHeader));
    if (newHeader == (ImageHeader *)NULL) {
	return((void *)NULL);
	}
    newHeader->width = width;
    newHeader->height = height;
    newHeader->xbase = xbase;
    newHeader->ybase = ybase;
    newHeader->tag = type;
    newHeader->comment = (char *)NULL;

    /*
     * Allocate the data area for the appropriate type of image, 
     * allocate and initialise the actual *Image and return it.
     * This exists in one form for each type of Image.
     */
    switch(type) {
      case IMAGE_GRAY: {
	GrayImage newGray;

	newGray = (GrayImage)malloc(sizeof(* newGray));
	if (newGray == (GrayImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(unsigned char));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newGray);
	    return((void *)NULL);
	    }
	newHeader->body.grayptr = newGray;
	newGray->header = newHeader;
	newGray->data = (unsigned char **)areaPtr;
	return((void *)newGray);
	break;			/* Paranoia strikes */
	}

      case IMAGE_FLOAT: {
	FloatImage newFloat;

	newFloat = (FloatImage)malloc(sizeof(* newFloat));
	if (newFloat == (FloatImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(float));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newFloat);
	    return((void *)NULL);
	    }
	newHeader->body.floatptr = newFloat;
	newFloat->header = newHeader;
	newFloat->data = (float **)areaPtr;
	return((void *)newFloat);
	break;
	}

      case IMAGE_RGB: {
	RGBImage newRGB;

	newRGB = (RGBImage)malloc(sizeof(* newRGB));
	if (newRGB == (RGBImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(RGB));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newRGB);
	    return((void *)NULL);
	    }
	newHeader->body.RGBptr = newRGB;
	newRGB->header = newHeader;
	newRGB->data = (RGB **)areaPtr;
	return((void *)newRGB);
	break;
	}

      case IMAGE_DOUBLE: {
	DoubleImage newDouble;

	newDouble = (DoubleImage)malloc(sizeof(* newDouble));
	if (newDouble == (DoubleImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(double));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newDouble);
	    return((void *)NULL);
	    }
	newHeader->body.doubleptr = newDouble;
	newDouble->header = newHeader;
	newDouble->data = (double **)areaPtr;
	return((void *)newDouble);
	break;
	}

      case IMAGE_BINARY: {
	BinaryImage newBinary;

	newBinary = (BinaryImage)malloc(sizeof(* newBinary));
	if (newBinary == (BinaryImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(char));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newBinary);
	    return((void *)NULL);
	    }
	newHeader->body.binaryptr = newBinary;
	newBinary->header = newHeader;
	newBinary->data = (char **)areaPtr;
	return((void *)newBinary);
	break;
	}

      case IMAGE_LONG: {
	LongImage newLong;

	newLong = (LongImage)malloc(sizeof(* newLong));
	if (newLong == (LongImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(long));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newLong);
	    return((void *)NULL);
	    }
	newHeader->body.longptr = newLong;
	newLong->header = newHeader;
	newLong->data = (long **)areaPtr;
	return((void *)newLong);
	break;
	}

      case IMAGE_PTR: {
	PtrImage newPtr;

	newPtr = (PtrImage)malloc(sizeof(* newPtr));
	if (newPtr == (PtrImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(void *));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newPtr);
	    return((void *)NULL);
	    }
	newHeader->body.ptrptr = newPtr;
	newPtr->header = newHeader;
	newPtr->data = (void ***)areaPtr;
	return((void *)newPtr);
	break;
	}

      case IMAGE_SHORT: {
	ShortImage newShort;

	newShort = (ShortImage)malloc(sizeof(* newShort));
	if (newShort == (ShortImage)NULL) {
	    free((void *)newHeader);
	    return((void *)NULL);
	    }
	areaPtr = allocImage(width, height, xbase, ybase, sizeof(short));
	if (areaPtr == (void **)NULL) {
	    free((void *)newHeader);
	    free((void *)newShort);
	    return((void *)NULL);
	    }
	newHeader->body.shortptr = newShort;
	newShort->header = newHeader;
	newShort->data = (short **)areaPtr;
	return((void *)newShort);
	break;
	}

      default: {
	panic("bad image tag");
	}
      }

    /*NOTREACHED*/
    }

void
im_Free_(void *im, ImageHeader *header)
{
    void **areaPtr;
    unsigned el_size;
    int xbase, ybase;

    assert(im != (void *)NULL);
    assert(header != (ImageHeader *)NULL);

    /* Pull out the data area and the size of the element */
    getAreaAndSize(im, header, &areaPtr, &el_size);

    /* and get rid of all of them */
    xbase = header->xbase;
    ybase = header->ybase;

    free((void *)im);
    if (header->comment != (char *)NULL) {
	free((void *)header->comment);
	}
    free((void *)header);
    freeImage(areaPtr, xbase, ybase, el_size);
    }

void
im_SetOffset_(void *im, ImageHeader *header, int newxbase, int newybase)
{
    int y;
    int oldxbase;
    int oldybase;

    assert(im != (void *)NULL);
    assert(header != (ImageHeader *)NULL);

    oldxbase = header->xbase;
    oldybase = header->ybase;

#define	FIX_PTRS(im, imtype) \
    { \
	imtype vim = (imtype)(im); \
	for (y = imGetYBase(vim); y <= imGetYMax(vim); y++) { \
	    vim->data[y] += (oldxbase - newxbase); \
	    } \
	vim->data += (oldybase - newybase); \
    }

    switch(header->tag) {
      case IMAGE_GRAY:		FIX_PTRS(im, GrayImage);	break;
      case IMAGE_FLOAT:		FIX_PTRS(im, FloatImage);	break;
      case IMAGE_RGB:		FIX_PTRS(im, RGBImage);		break;
      case IMAGE_DOUBLE:	FIX_PTRS(im, DoubleImage);	break;
      case IMAGE_BINARY:	FIX_PTRS(im, BinaryImage);	break;
      case IMAGE_LONG:		FIX_PTRS(im, LongImage);	break;
      case IMAGE_PTR:		FIX_PTRS(im, PtrImage);		break;
      case IMAGE_SHORT:		FIX_PTRS(im, ShortImage);	break;
      default: {
	panic("bad image tag");
	}
      }

#undef	FIX_PTRS

    header->xbase = newxbase;
    header->ybase = newybase;
    }

void *
imLoad(ImageType type, char *filename)
{
    FILE *inFile;
    void *im;

    /* Open the file, imLoadF on it, then close it */
    assert(filename != (char *)NULL);
    inFile = fopen(filename, "r");
    if (inFile == (FILE *)NULL) {
	return((void *)NULL);
	}

    im = imLoadF(type, inFile);

    if (fclose(inFile) == EOF) {
	/*
	 * It would be a strange day that fclose on a read-only file
	 * gave an error, but...
	 *
	 * Sigh - have to track down the image's header so we can free it.
	 */
	if (im) {
	    ImageHeader *header = getHeader(im, type);
	    im_Free_(im, header);
	    }
	return((void *)NULL);
	}

    return(im);
    }

void *
imLoadF(ImageType type, FILE *inFile)
{
    char fileHeader[PBM_MAX_LINELEN];
    void *im;
    int c;
    int i;
    ImageType filetype;
    void * (*readfunc)(FILE *inFile, ImageHeader **readimHeader);
    void *readim;
    ImageHeader *readimHeader;

    assert(inFile != (FILE *)NULL);

    /*
     * Read up to the first whitespace in order to find the file's header.
     */
    i = 0;
    do {
	c = getc(inFile);
	if (c == EOF) {
	    return((void *)NULL);
	    }
	fileHeader[i++] = c;
	} while (!isspace(c));
    fileHeader[--i] = '\0';		/* Clobber the whitespace */

    /* Determine who is supposed to handle this sort of file */
    for (i = 0; i < NREADERS; i++) {
	if (strcmp(fileHeader, fileReaders[i].filetag) == 0) {
	    /* Found it */
	    filetype = fileReaders[i].filetype;
	    readfunc = fileReaders[i].readfunc;
	    break;
	    }
	}
    if (i == NREADERS) {
	/* Didn't match any of the ones in the table - unknown type. */
	return((void *)NULL);
	}

    /* Clear the comment buffer */
    incommentsize = 0;

    /* Read in the file */
    readim = (*readfunc)(inFile, &readimHeader);
    if (readim == (void *)NULL) {
	/* Didn't load for whatever reason */
	return((void *)NULL);
	}

    if (filetype == type) {
	/* The file was of the expected type - no conversion required */
	if (!setComment(readimHeader)) {
	    /* Sigh - stumbled over the comment */
	    im_Free_(readim, readimHeader);
	    return((void *)NULL);
	    }
	return(readim);
	}

    /*
     * OK. We read in a file, and it wasn't what we expected. We get to
     * promote it to the expected image type, if that's defined.
     *
     * If that conversion isn't a promotion, kick out.
     */
    if (!convertTable[filetype][type].isPromotion) {
	im_Free_(readim, readimHeader);
	return((void *)NULL);
	}
    
    /* Convert... */
    im = im_Promote_(readim, readimHeader, type);
    if (im == (void *)NULL) {
	/* Didn't work. */
	im_Free_(readim, readimHeader);
	return((void *)NULL);
	}

    /* Kill the image we read in, and return the promoted one. */
    im_Free_(readim, readimHeader);

    /* Stick the comment from the file into the header */
    readimHeader = getHeader(im, type);
    if (!setComment(readimHeader)) {
	/* Died in the comment copy */
	im_Free_(im, readimHeader);
	return((void *)NULL);
	}

    return(im);
    }

int
im_Save_(void *im, ImageHeader *header, char *filename)
{
    FILE *outFile;
    
    assert(filename != (char *)NULL);
    assert(im != (void *)NULL);
    assert(header != (ImageHeader *)NULL);

    /* Open the file, imSaveF on it, then close it */
    outFile = fopen(filename, "w");
    if (outFile == (FILE *)NULL) {
	return(-1);
	}

    /* Write the image */
    if (im_SaveF_(im, header, outFile) == -1) {
	(void)fclose(outFile);
	return(-1);
	}

    /* and close the file */
    if (fclose(outFile) == EOF) {
	/* Bah. */
	return(-1);
	}

    return(0);
    }

int
im_SaveF_(void *im, ImageHeader *header, FILE *outFile)
{
    void *rect;