// ------------------------------------------------------------
// imageio.c
//
// Reading writing tiff images
//
// 12.03.2005, J.Ahrensfeld
// ------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#ifndef WIN32
#include <sys/time.h>
else
#include <time.h>
#endif

#include <tiffio.h>
#include "mtypes.h"
#include "imageio.h"
#include "mutil.h"

// ------------------------------------------------------------
void ImageInit(image_t *pObj, int num_row, int num_col, int num_ch)
{
	pObj->num_row = num_row;
	pObj->num_col = num_col;
	pObj->num_ch = num_ch;
	pObj->num_pixel = num_row*num_col;

	pObj->pColor_data = (double*)malloc(pObj->num_pixel*num_ch*sizeof(double));
	memset(pObj->pColor_data, 0, pObj->num_pixel*num_ch*sizeof(double));

}

// ------------------------------------------------------------
void ImageFree(image_t *pObj)
{
	pObj->num_row = 0;
	pObj->num_col = 0;
	pObj->num_pixel = 0;
	pObj->num_ch = 0;

	if (pObj->pColor_data)

		free(pObj->pColor_data);

}

// ------------------------------------------------------------
void ImageCopy(image_t *pSrc, image_t *pDst)
{
	pDst->num_row = pSrc->num_row;
	pDst->num_col = pSrc->num_col;
	pDst->num_pixel = pSrc->num_pixel;
	pDst->num_ch = pSrc->num_ch;

	if (!pDst->pColor_data)
		pDst->pColor_data = (double*)malloc(pSrc->num_ch*pSrc->num_pixel*sizeof(double));


	memcpy(pDst->pColor_data, pSrc->pColor_data, pSrc->num_ch*pSrc->num_pixel*sizeof(double));

}

// ------------------------------------------------------------
int ImageLoadTiff(image_t *pObj, char *filename)
{

	TIFF *pTifComp;
	UINT16 config, nBits, nSamples, photometric;
	UINT32 i, num_col, num_row, scan_size, size, num_color_ch;
	double k_norm;
	double c;

	UINT8 *pImage_comp8;
	int status;

	pTifComp  = TIFFOpen(filename,"r");

	if (!pTifComp)
	{
		fprintf(stderr,"Unable to open input file %s\n",filename);
		return -1;
	}

	status = TIFFGetField(pTifComp, TIFFTAG_IMAGEWIDTH, &num_col);
	status = TIFFGetField(pTifComp, TIFFTAG_IMAGELENGTH, &num_row);
	status = TIFFGetField(pTifComp, TIFFTAG_BITSPERSAMPLE, &nBits);
	status = TIFFGetField(pTifComp, TIFFTAG_PLANARCONFIG, &config);
	status = TIFFGetField(pTifComp, TIFFTAG_PHOTOMETRIC, &photometric);
	status = TIFFGetField(pTifComp, TIFFTAG_SAMPLESPERPIXEL, &nSamples);

	num_color_ch = (UINT32)nSamples;
	pObj->num_row = num_row;
	pObj->num_col = num_col;
	pObj->num_pixel = num_row*num_col;
	pObj->num_ch = num_color_ch;

	pObj->pColor_data = (double*)malloc(num_color_ch*pObj->num_pixel*sizeof(double));

	scan_size = TIFFScanlineSize(pTifComp);

	pImage_comp8 = (UINT8*)_TIFFmalloc(scan_size*num_row*sizeof(UINT8));

	for (i=0; i < num_row; i++)
		status = TIFFReadScanline(pTifComp, &pImage_comp8[i*scan_size], i, 0);

	TIFFClose(pTifComp);

	k_norm = 1.0/(pow(2.0,nBits)-1);

	for (i=0; i < num_color_ch*num_col*num_row; i++)
	{
		c = k_norm*(double)pImage_comp8[i];
		pObj->pColor_data[i] = c;
	}

	free(pImage_comp8);

}

// ------------------------------------------------------------
int ImageSaveTiff(image_t *pObj, double *pAlpha, char *filename)
{

	TIFF *pTifComp;
	ttag_t config, nBits, nSamples, photometric, extra_sample_info;
	UINT32 i, num_col, num_row, scan_size, size;
	double k_norm;
	double c, a;

	UINT8 *pImage_comp8;
	int status;

	pTifComp  = TIFFOpen(filename,"w");

	if (!pTifComp)
	{
		fprintf(stderr,"Unable to open input file %s\n",filename);
		return 1;
	}

	nBits = 8;
	num_row = pObj->num_row;
	num_col = pObj->num_col;
	config = PLANARCONFIG_CONTIG;
	photometric = PHOTOMETRIC_RGB;

	nSamples = (ttag_t)pObj->num_ch;

	extra_sample_info = 0;
	if (pAlpha)
	{
		nSamples++;
		extra_sample_info = EXTRASAMPLE_ASSOCALPHA;
		status = TIFFSetField(pTifComp, TIFFTAG_EXTRASAMPLES, 1, &extra_sample_info);

	}

	status = TIFFSetField(pTifComp, TIFFTAG_IMAGEWIDTH, num_col);
	status = TIFFSetField(pTifComp, TIFFTAG_IMAGELENGTH, num_row);
	status = TIFFSetField(pTifComp, TIFFTAG_ROWSPERSTRIP, num_row);
	status = TIFFSetField(pTifComp, TIFFTAG_BITSPERSAMPLE, nBits);
	status = TIFFSetField(pTifComp, TIFFTAG_PLANARCONFIG, config);
	status = TIFFSetField(pTifComp, TIFFTAG_PHOTOMETRIC, photometric);
	status = TIFFSetField(pTifComp, TIFFTAG_SAMPLESPERPIXEL, nSamples);
	status = TIFFSetField(pTifComp, TIFFTAG_ARTIST, "JDI, J. Ahrensfeld");

//TIFFTAG_IMAGEDESCRIPTION
//TIFFTAG_SOFTWARE                305     /* name & release */
//TIFFTAG_DATETIME                306     /* creation date and time */

	scan_size = nSamples*num_col;

	pImage_comp8 = (UINT8*)_TIFFmalloc(scan_size*num_row*sizeof(UINT8));

	k_norm = pow(2.0,nBits)-1;

	if (pAlpha)
	{
		for (i=0; i < num_col*num_row; i++)
		{
			a = smin(smax(pAlpha[i],0),1);

			c = pObj->pColor_data[(nSamples-1)*i+0];
			c = a*smin(smax(c,0),1);
			pImage_comp8[nSamples*i+0] = (UINT8)(k_norm*c);

			c = pObj->pColor_data[(nSamples-1)*i+1];
			c = a*smin(smax(c,0),1);
			pImage_comp8[nSamples*i+1] = (UINT8)(k_norm*c);

			c = pObj->pColor_data[(nSamples-1)*i+2];
			c = a*smin(smax(c,0),1);
			pImage_comp8[nSamples*i+2] = (UINT8)(k_norm*c);

			pImage_comp8[nSamples*i+3] = (UINT8)(k_norm*a);

		}
	}
	else
	{
		for (i=0; i < nSamples*num_col*num_row; i++)
		{
			c = pObj->pColor_data[i];
			c = smin(smax(c,0),1);
			pImage_comp8[i] = (UINT8)(k_norm*c);
		}
	}

	for (i=0; i < num_row; i++)
	{
		status = TIFFWriteScanline(pTifComp, &pImage_comp8[i*scan_size], i, 0);
		if (status < 0)
			TIFFError("ImageSaveTiff", "%s", "Hallo") ;
	}

	TIFFClose(pTifComp);
	free(pImage_comp8);

	return 0;

}