/****************************************/
/*	iraftofocas	valdes 7 11 90	*/
/*					*/
/*	Convert IRAF format image to	*/
/*	native FOCAS format images	*/
/****************************************/
#include	<stdio.h>
#include	"image.h"

static char *help[] = {
    "Convert IRAF format to native FOCAS format image",
    " usage: iraftofocas irafimage focasimage",
    "  Arguments: irafimage - IRAF format image to be converted",
    "             focasimage - Native FOCAS format image",
    0
};


main (argc, argv)
int     argc;
char   *argv[];
{
    int i, in, out;
    struct imgdef   imhdr;
    PIXEL bfr[MAXBUF];

    if (argc < 3) {
	for (i = 0; help[i] != 0; i++)
	    fprintf (stderr, "%s\n", help[i]);
	exit (0);
    }

    in = iraf_imopen (argv[1], &imhdr, 0);
    out = foc_imopen (argv[2], &imhdr, 1);

    for (i = 0; i < imhdr.naxis2; i++) {
	iraf_rdimage (in, 0, i, imhdr.naxis1, &imhdr, bfr);
	foc_wtimage (out, 0, i, imhdr.naxis1, &imhdr, bfr);
    }

    iraf_imclose (in);
    foc_imclose (out);
}

#define		EXITONERR	0/* Exit on error		 */
int errmode;
static int ier;
static float rbuf[MAXBUF];

/* Open image file and return fd */
iraf_imopen (file, imhdr, mode)
char   *file;
struct imgdef  *imhdr;
int     mode;
/* If mode = 0  Read image header */
/* If mode = 1  Write image header */
/* If mode = 2  If file exists read header otherwise write header */
{
    int     fdim, axlen[7];

	    c_imopen1 (file, 0, &fdim, &ier);
	    if (ier) {
		fprintf (stderr, "iraf_imopen: Can't read %s\n", file);
		if (errmode != EXITONERR)
		    return (-1);
		exit (0);
	    }
	    iraf_rdimhdr (fdim, imhdr);
    return (fdim);
}

/* Close image file */
iraf_imclose (fdim)
int    fdim;
{
    c_imclos (fdim, &ier);
}

/*Read image header and return read status*/
iraf_rdimhdr (fdim, imhdr)
int     fdim;
struct imgdef  *imhdr;
{
    int     i, axlen[7], naxis, dtype;
    float   r;
    char    sval[80];

    imhdr->simple[0] = 'T';
    imhdr->blksiz = 2880;
    imhdr->dflags = 0;
    imhdr->maptyp = 0;
    imhdr->maxpxl = MAXPXL;
    imhdr->minpxl = -MAXPXL;
    imhdr->bscale = 1.;
    imhdr->bzero = 0.;
    imhdr->crpix1 = 0.;
    imhdr->cdelt1 = 1.;
    imhdr->crpix2 = 0.;
    imhdr->cdelt2 = 1.;
    imhdr->blank = -(MAXPXL - 1);
    imhdr->dscale = 1.;
    imhdr->dzero = 0.;
    imhdr->object[0] = 0;
    imhdr->origin[0] = 0;
    imhdr->date[0] = 0;
    imhdr->observer[0] = 0;
    imhdr->comment[0] = 0;

    c_imgsiz (fdim, axlen, &naxis, &dtype, &ier);

    imhdr->naxis = naxis;
    imhdr->naxis1 = axlen[0];
    imhdr->naxis2 = axlen[1];
    if (dtype == 3) {
	imhdr->bitpix = 16;
	imhdr->bytepix = 2;
    } else {
	imhdr->bitpix = 32;
	imhdr->bytepix = 4;
    }

    c_imgkwi (fdim, "dflags",  &i, &ier); if (!ier) imhdr->dflags = i;
    c_imgkwi (fdim, "maptyp",  &i, &ier); if (!ier) imhdr->maptyp = i;
    c_imgkwi (fdim, "datamax", &i, &ier); if (!ier) imhdr->maxpxl = i;
    c_imgkwi (fdim, "datamin", &i, &ier); if (!ier) imhdr->minpxl = i;
    c_imgkwr (fdim, "bscale",  &r, &ier); if (!ier) imhdr->bscale = r;
    c_imgkwr (fdim, "bzero",   &r, &ier); if (!ier) imhdr->bzero  = r;
    c_imgkwr (fdim, "xoffset", &r, &ier); if (!ier) imhdr->crpix1 = r;
    c_imgkwr (fdim, "xstep",   &r, &ier); if (!ier) imhdr->cdelt1 = r;
    c_imgkwr (fdim, "yoffset", &r, &ier); if (!ier) imhdr->crpix2 = r;
    c_imgkwr (fdim, "ystep",   &r, &ier); if (!ier) imhdr->cdelt2 = r;
    c_imgkwi (fdim, "blank",   &i, &ier); if (!ier) imhdr->blank  = i;
    c_imgkwr (fdim, "dscale",  &r, &ier); if (!ier) imhdr->dscale = r;
    c_imgkwr (fdim, "dzero",   &r, &ier); if (!ier) imhdr->dzero  = r;
    c_imgkwc (fdim, "title", sval, &ier);
    if (!ier)
        strncpy (imhdr->object, sval, 32);
    c_imgkwc (fdim, "origin", sval, &ier);
    if (!ier)
        strncpy (imhdr->origin, sval, 32);
    c_imgkwc (fdim, "date-obs", sval, &ier);
    if (!ier)
        strncpy (imhdr->date, sval, 32);
    c_imgkwc (fdim, "observer", sval, &ier);
    if (!ier)
        strncpy (imhdr->observer, sval, 32);
}

/*Read image file*/
iraf_rdimage (fdim, x, y, pixels, imhdr, buf)
int     fdim;
int     x, y, pixels;
struct imgdef  *imhdr;
PIXEL * buf;
{
    int x1, x2, y1, y2;

    if (pixels > MAXBUF) {
	fprintf (stderr, "rdimage: Insufficient input buffer space\n");
	if (errmode == EXITONERR)
	    exit (0);
	return (errmode);
    }
    x1 = x + 1;
    x2 = x1 + pixels - 1;
    y1 = y + 1;
    y2 = y1;
    c_imgs2r (fdim, rbuf, x1, x2, y1, y2, &ier);
    if (ier) {
	fprintf (stderr, "rdimage: Error reading image\n");
	if (errmode == EXITONERR)
	    exit (0);
	return (errmode);
    }
    for (x1 = 0; x1 < pixels; x1++)
	buf[x1] = rbuf[x1];
    return (0);
}

static unsigned char    cbuf[MAXBUF];

/* Open image file and return fd */
foc_imopen (file, imhdr, mode)
char   *file;
struct imgdef  *imhdr;
int     mode;
/* If mode = 0  Read image header */
/* If mode = 1  Write image header */
/* If mode = 2  If file exists read header otherwise write header */
{
    int     fdim;

	    if ((fdim = creat (file, 0660)) < 0) {
		fprintf (stderr, "foc_imopen: Can't write %s\n", file);
		if (errmode != EXITONERR)
		    return (-1);
		exit ();
	    }
	    foc_wtimhdr (fdim, imhdr);
    return (fdim);
}

/* Close image file */
foc_imclose (fdim)
int	fdim;
{
    close (fdim);
}


/*Write image header and return write status*/
foc_wtimhdr (fdim, imhdr)
int     fdim;
struct imgdef  *imhdr;
{
    int     i;

    lseek (fdim, 0L, 0);
    i = write (fdim, imhdr, sizeof (struct imgdef));
    if (i < 0) {
	fprintf (stderr, "wtimhdr: Error in writing standard header\n");
	if (errmode == EXITONERR)
	    exit ();
    }
    return (i);
}


/*Write image file*/
foc_wtimage (fdim, x, y, pixels, imhdr, buf)
int     fdim;
int     x, y, pixels;
struct imgdef  *imhdr;
PIXEL * buf;
{
    int     i;
    short  *sp;

    if (pixels * imhdr->bytepix > MAXBUF) {
	fprintf (stderr, "wtimage: Insufficient output buffer space\n");
	if (errmode == EXITONERR)
	    exit ();
	return (errmode);
    }
    lseek (fdim, sizeof (struct imgdef) + (y * imhdr->naxis1 + x) * imhdr->bytepix, 0);
    switch (imhdr->bytepix) {
	case 1: 
	    for (i = 0; i < pixels; i++) {
		if (buf[i] < 0)
		    cbuf[i] = 0;
		else
		    if (buf[i] > 255)
			cbuf[i] = 255;
		    else
			cbuf[i] = buf[i];
	    }
	    i = write (fdim, cbuf, pixels * imhdr->bytepix);
	    break;
	case 2: 
	    sp = (short *) cbuf;
	    for (i = 0; i < pixels; i++) {
		if (buf[i] < -32767)
		    sp[i] = -32767;
		else
		    if (buf[i] > 32767)
			sp[i] = 32767;
		    else
			sp[i] = buf[i];
	    }
	    i = write (fdim, sp, pixels * imhdr->bytepix);
	    break;
	case 4: 
	    i = write (fdim, buf, pixels * imhdr->bytepix);
	    break;
    }
    if (i != pixels * imhdr->bytepix) {
	fprintf (stderr, "wtimage: Error in writing image\n");
	fprintf (stderr, "pixels = %d bytepix = %d i = %d\n", pixels, imhdr->bytepix, i);
	if (errmode == EXITONERR)
	    exit ();
	return (errmode);
    }
    return (0);
}