/***
 **     libface - Library of face recognition and supporting algorithms
        Copyright (c) 2003 Stefan Farthofer

	This file is part of libface, which is

        free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

	For further information seek us at http://sourceforge.net/projects/openbio/
**	or write an email to dimitri.pissarenko@gmx.net or farthofer@chello.at.
***/
/* implementation of image handling functions */

#include <malloc.h>
#include <memory.h>
#include <IL/IL.h>
#include <IL/ILU.h>
#include "frbase.h"
#include "fr.h"

/* maybe put this in another header if we accumulate enough util functions */
int frutilEvalILErrors(void);

int frImgLoadFile(char* filename, FRimage* image) {
	ILuint img;
	int err;

	/* load image with IL */
	ilGenImages(1, &img);
	ilBindImage(img);
	ilLoadImage(filename);
	ilConvertImage(IL_LUMINANCE, IL_FLOAT);

	/* when loaded ok copy bound image to image struct */
	if ((err = frutilEvalILErrors()) == FR_OK) {
		err = frImgLoadBound(image);
	}

	ilDeleteImages(1, &img);
	return err;
}

int frImgSaveFile(char* filename, FRimage* image) {
	ILuint img;
	int err;

	ilGenImages(1, &img);
	ilBindImage(img);
	ilTexImage(image->width,image->height,1,1,IL_LUMINANCE, IL_FLOAT, image->imgdata);
	ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
	ilSaveImage(filename);
	ilDeleteImages(1, &img);
	if ((err = frutilEvalILErrors()) != FR_OK)
		return err;
	return FR_OK;
}

int frImgLoadMem(void* mem, size_t sz, FRimage* image, ILenum type) {
	ILuint img;
	int err;

	/* load image with IL */
	ilGenImages(1, &img);
	ilBindImage(img);
	ilLoadL(type,mem,(ILuint)sz);
	ilConvertImage(IL_LUMINANCE, IL_FLOAT);

	/* when loaded ok copy bound image to image struct */
	if ((err = frutilEvalILErrors()) == FR_OK) {
		err = frImgLoadBound(image);
	}

	ilDeleteImages(1, &img);
	return err;
}

/* used to load real RAW images with 1 Byte per Pixel, don't confuse with
   IL_RAW since this format does expect a header with the width/height of
   the image to be loaded.
 */
int frImgLoadRaw(void* mem, int width, int height, FRimage* image) {
	ILuint img;
	int err = FR_OK;

	ilGenImages(1, &img);
	ilBindImage(img);
	ilTexImage(width, height, 1, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, mem);
	ilConvertImage(IL_LUMINANCE, IL_FLOAT);

	/* check if there were errors, then free IL image, set struct elements and return */
	err = frutilEvalILErrors();

	ilDeleteImages(1, &img);
	image->width = width;
	image->height = height;
	return FR_OK;
}

int frImgGetILImg(ILuint* imgnr, FRimage* image) {
	int err;

	ilGenImages(1, imgnr);
	ilBindImage(*imgnr);
	ilTexImage(image->width,image->height,1,1,IL_LUMINANCE, IL_FLOAT, image->imgdata);
	ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);

	/* if anything went wrong set imgnr to 0 and return with error */
	if ((err = frutilEvalILErrors()) != FR_OK) {
		ilDeleteImages(1, imgnr);
		*imgnr = 0;
		return err;
	}
	return FR_OK;
}

int frImgGetILImgFloat(ILuint* imgnr, FRimage* image) {
	int err;

	ilGenImages(1, imgnr);
	ilBindImage(*imgnr);
	ilTexImage(image->width,image->height,1,1,IL_LUMINANCE, IL_FLOAT, image->imgdata);

	/* if anything went wrong set imgnr to 0 and return with error */
	if ((err = frutilEvalILErrors()) != FR_OK) {
		ilDeleteImages(1, imgnr);
		*imgnr = 0;
		return err;
	}
	return FR_OK;
}

void frImgFree(FRimage* image) {
	if (image->imgdata != NULL) {
		free(image->imgdata);
	}
}

/* allocates an image struct and loads the currently bound IL image */
int frImgLoadBound(FRimage* image) {
	size_t sz;

	image->width = ilGetInteger(IL_IMAGE_WIDTH);
	image->height = ilGetInteger(IL_IMAGE_HEIGHT);
	sz = sizeof(float) * image->width * image->height;
	image->imgdata = (float*) malloc(sz);
	if (image->imgdata == NULL) return FR_ERR_NOMEM;
	memcpy((void*)image->imgdata, ilGetData(), sz);
	return FR_OK;
}

int frImgResize(FRimage* dst, FRimage* src, unsigned int w, unsigned int h) {
	ILuint img;
	int err;

	if ((err = frImgGetILImgFloat(&img, src))) return err;
	iluScale(w,h,1);
	if (frutilEvalILErrors()) return FR_ERR_IL;
	return frImgLoadBound(dst);
}

int frutilEvalILErrors(void) {
	ILenum err;
	int nr = 0;

	/* for now we don't do any logging, this should change in the future */
	while ((err = ilGetError()) != IL_NO_ERROR) {
		/* printf("%s %s", prefix, iluErrorString(err)); */
		nr++;
	}
	/* just say IL error for now */
	if (nr > 0)
		return FR_ERR_IL;
	else
		return FR_OK;
}