diff options
Diffstat (limited to 'tksao/wcssubs/imhfile.c')
| -rw-r--r-- | tksao/wcssubs/imhfile.c | 1941 |
1 files changed, 1941 insertions, 0 deletions
diff --git a/tksao/wcssubs/imhfile.c b/tksao/wcssubs/imhfile.c new file mode 100644 index 0000000..b618686 --- /dev/null +++ b/tksao/wcssubs/imhfile.c @@ -0,0 +1,1941 @@ +/*** File imhfile.c + *** March 27, 2012 + *** By Jessica Mink, jmink@cfa.harvard.edu + *** Harvard-Smithsonian Center for Astrophysics + *** Copyright (C) 1996-2012 + *** Smithsonian Astrophysical Observatory, Cambridge, MA, USA + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Correspondence concerning WCSTools should be addressed as follows: + Internet email: jmink@cfa.harvard.edu + Postal address: Jessica Mink + Smithsonian Astrophysical Observatory + 60 Garden St. + Cambridge, MA 02138 USA + + * Module: imhfile.c (IRAF .imh image file reading and writing) + * Purpose: Read and write IRAF image files (and translate headers) + * Subroutine: check_immagic (irafheader, teststring ) + * Verify that file is valid IRAF imhdr or impix + * Subroutine: irafrhead (filename, lfhead, fitsheader, lihead) + * Read IRAF image header + * Subroutine: irafrimage (fitsheader) + * Read IRAF image pixels (call after irafrhead) + * Subroutine: same_path (pixname, hdrname) + * Put filename and header path together + * Subroutine: iraf2fits (hdrname, irafheader, nbiraf, nbfits) + * Convert IRAF image header to FITS image header + * Subroutine: irafwhead (hdrname, irafheader, fitsheader) + * Write IRAF header file + * Subroutine: irafwimage (hdrname, irafheader, fitsheader, image ) + * Write IRAF image and header files + * Subroutine: fits2iraf (fitsheader, irafheader) + * Convert FITS image header to IRAF image header + * Subroutine: irafgeti4 (irafheader, offset) + * Get 4-byte integer from arbitrary part of IRAF header + * Subroutine: irafgetc2 (irafheader, offset) + * Get character string from arbitrary part of IRAF v.1 header + * Subroutine: irafgetc (irafheader, offset) + * Get character string from arbitrary part of IRAF header + * Subroutine: iraf2str (irafstring, nchar) + * Convert 2-byte/char IRAF string to 1-byte/char string + * Subroutine: str2iraf (string, irafstring, nchar) + * Convert 1-byte/char string to IRAF 2-byte/char string + * Subroutine: irafswap (bitpix,string,nbytes) + * Swap bytes in string in place, with FITS bits/pixel code + * Subroutine: irafswap2 (string,nbytes) + * Swap bytes in string in place + * Subroutine irafswap4 (string,nbytes) + * Reverse bytes of Integer*4 or Real*4 vector in place + * Subroutine irafswap8 (string,nbytes) + * Reverse bytes of Real*8 vector in place + * Subroutine irafsize (filename) + * Return length of file in bytes + * Subroutine isiraf (filename) + * Return 1 if IRAF .imh file, else 0 + + + * Copyright: 2000 Smithsonian Astrophysical Observatory + * You may do anything you like with this file except remove + * this copyright. The Smithsonian Astrophysical Observatory + * makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without + * express or implied warranty. + */ + +#include <stdio.h> /* define stderr, FD, and NULL */ +#include <stdlib.h> +#include <unistd.h> +#include <fcntl.h> +#include <string.h> +#include <time.h> +#include <sys/types.h> +#include "fitsfile.h" + +/* Parameters from iraf/lib/imhdr.h for IRAF version 1 images */ +#define SZ_IMPIXFILE 79 /* name of pixel storage file */ +#define SZ_IMHDRFILE 79 /* length of header storage file */ +#define SZ_IMTITLE 79 /* image title string */ +#define LEN_IMHDR 2052 /* length of std header */ + +/* Parameters from iraf/lib/imhdr.h for IRAF version 2 images */ +#define SZ_IM2PIXFILE 255 /* name of pixel storage file */ +#define SZ_IM2HDRFILE 255 /* name of header storage file */ +#define SZ_IM2TITLE 383 /* image title string */ +#define LEN_IM2HDR 2046 /* length of std header */ + +/* Offsets into header in bytes for parameters in IRAF version 1 images */ +#define IM_HDRLEN 12 /* Length of header in 4-byte ints */ +#define IM_PIXTYPE 16 /* Datatype of the pixels */ +#define IM_NDIM 20 /* Number of dimensions */ +#define IM_LEN 24 /* Length (as stored) */ +#define IM_PHYSLEN 52 /* Physical length (as stored) */ +#define IM_PIXOFF 88 /* Offset of the pixels */ +#define IM_CTIME 108 /* Time of image creation */ +#define IM_MTIME 112 /* Time of last modification */ +#define IM_LIMTIME 116 /* Time of min,max computation */ +#define IM_MAX 120 /* Maximum pixel value */ +#define IM_MIN 124 /* Maximum pixel value */ +#define IM_PIXFILE 412 /* Name of pixel storage file */ +#define IM_HDRFILE 572 /* Name of header storage file */ +#define IM_TITLE 732 /* Image name string */ + +/* Offsets into header in bytes for parameters in IRAF version 2 images */ +#define IM2_HDRLEN 6 /* Length of header in 4-byte ints */ +#define IM2_PIXTYPE 10 /* Datatype of the pixels */ +#define IM2_SWAPPED 14 /* Pixels are byte swapped */ +#define IM2_NDIM 18 /* Number of dimensions */ +#define IM2_LEN 22 /* Length (as stored) */ +#define IM2_PHYSLEN 50 /* Physical length (as stored) */ +#define IM2_PIXOFF 86 /* Offset of the pixels */ +#define IM2_CTIME 106 /* Time of image creation */ +#define IM2_MTIME 110 /* Time of last modification */ +#define IM2_LIMTIME 114 /* Time of min,max computation */ +#define IM2_MAX 118 /* Maximum pixel value */ +#define IM2_MIN 122 /* Maximum pixel value */ +#define IM2_PIXFILE 126 /* Name of pixel storage file */ +#define IM2_HDRFILE 382 /* Name of header storage file */ +#define IM2_TITLE 638 /* Image name string */ + +/* Codes from iraf/unix/hlib/iraf.h */ +#define TY_CHAR 2 +#define TY_SHORT 3 +#define TY_INT 4 +#define TY_LONG 5 +#define TY_REAL 6 +#define TY_DOUBLE 7 +#define TY_COMPLEX 8 +#define TY_POINTER 9 +#define TY_STRUCT 10 +#define TY_USHORT 11 +#define TY_UBYTE 12 + +#define LEN_IRAFHDR 25000 +#define LEN_PIXHDR 1024 +#define LEN_FITSHDR 11520 + +int check_immagic(); +int irafgeti4(); +float irafgetr4(); +char *irafgetc2(); +char *irafgetc(); +char *iraf2str(); +static char *same_path(); +static void irafputr4(); +static void irafputi4(); +static void irafputc2(); +static void irafputc(); +static void str2iraf(); +static int headswap=-1; /* =1 to swap data bytes of foreign IRAF file */ +static void irafswap(); +static void irafswap2(); +static void irafswap4(); +static void irafswap8(); +int head_version (); +int pix_version (); +int irafncmp (); +static int machswap(); +static int irafsize(); + +#define SECONDS_1970_TO_1980 315532800L + +/* Subroutine: irafrhead + * Purpose: Open and read the iraf .imh file, translating it to FITS, too. + * Returns: NULL if failure, else pointer to IRAF .imh image header + * Notes: The imhdr format is defined in iraf/lib/imhdr.h, some of + * which defines or mimicked, above. + */ + +char * +irafrhead (filename, lihead) + +char *filename; /* Name of IRAF header file */ +int *lihead; /* Length of IRAF image header in bytes (returned) */ +{ + FILE *fd; + int nbr; + char *irafheader; + int nbhead, nbytes; + int imhver; + + headswap = -1; + *lihead = 0; + + /* open the image header file */ + fd = fopen (filename, "rb"); + if (fd == NULL) { + fprintf (stderr, "IRAFRHEAD: cannot open file %s to read\n", filename); + return (NULL); + } + + /* Find size of image header file */ + if ((nbhead = irafsize (fd)) <= 0) { + fprintf (stderr, "IRAFRHEAD: cannot read file %s, size = %d\n", + filename, nbhead); + return (NULL); + } + + /* allocate initial sized buffer */ + nbytes = nbhead + 5000; + irafheader = (char *) calloc (nbytes/4, 4); + if (irafheader == NULL) { + (void)fprintf(stderr, "IRAFRHEAD Cannot allocate %d-byte header\n", + nbytes); + return (NULL); + } + *lihead = nbytes; + + /* Read IRAF header */ + nbr = fread (irafheader, 1, nbhead, fd); + fclose (fd); + + /* Reject if header less than minimum length */ + if (nbr < LEN_PIXHDR) { + (void)fprintf(stderr, "IRAFRHEAD header file %s: %d / %d bytes read.\n", + filename,nbr,LEN_PIXHDR); + free (irafheader); + return (NULL); + } + + /* Check header magic word */ + imhver = head_version (irafheader); + if (imhver < 1) { + free (irafheader); + (void)fprintf(stderr, "IRAFRHEAD: %s is not a valid IRAF image header\n", + filename); + return(NULL); + } + + /* check number of image dimensions + if (imhver == 2) + ndim = irafgeti4 (irafheader, IM2_NDIM]) + else + ndim = irafgeti4 (irafheader, IM_NDIM]) + if (ndim < 2) { + free (irafheader); + (void)fprintf(stderr, "File %s does not contain 2d image\n", filename); + return (NULL); + } */ + + return (irafheader); +} + + +char * +irafrimage (fitsheader) + +char *fitsheader; /* FITS image header (filled) */ +{ + FILE *fd; + char *bang; + int naxis, naxis1, naxis2, naxis3, npaxis1, npaxis2,bitpix, bytepix, pixswap, i; + char *image; + int nbr, nbimage, nbaxis, nbl, nbdiff, lpname; + char *pixheader; + char *linebuff, *pixchar; + int imhver, lpixhead, len; + char pixname[SZ_IM2PIXFILE+1]; + char newpixname[SZ_IM2HDRFILE+1]; + + /* Convert pixel file name to character string */ + hgetm (fitsheader, "PIXFIL", SZ_IM2PIXFILE, pixname); + + /* Drop trailing spaces */ + lpname = strlen (pixname); + pixchar = pixname + lpname - 1; + while (*pixchar == ' ') + *pixchar = (char) 0; + + hgeti4 (fitsheader, "PIXOFF", &lpixhead); + + /* Open pixel file, ignoring machine name if present */ + if ((bang = strchr (pixname, '!')) != NULL ) + fd = fopen (bang + 1, "rb"); + else + fd = fopen (pixname, "rb"); + + /* If not at pathname in header, try same directory as header file */ + if (!fd) { + hgetm (fitsheader, "IMHFIL", SZ_IM2HDRFILE, newpixname); + len = strlen (newpixname); + newpixname[len-3] = 'p'; + newpixname[len-2] = 'i'; + newpixname[len-1] = 'x'; + fd = fopen (newpixname, "rb"); + } + + /* Print error message and exit if pixel file is not found */ + if (!fd) { + (void)fprintf(stderr, + "IRAFRIMAGE: Cannot open IRAF pixel file %s\n", pixname); + return (NULL); + } + + /* Read pixel header */ + pixheader = (char *) calloc (lpixhead/4, 4); + if (pixheader == NULL) { + (void)fprintf(stderr, "IRAFRIMAGE Cannot allocate %d-byte pixel header\n", + lpixhead); + return (NULL); + } + nbr = fread (pixheader, 1, lpixhead, fd); + + /* Check size of pixel header */ + if (nbr < lpixhead) { + (void)fprintf(stderr, "IRAF pixel file %s: %d / %d bytes read.\n", + pixname,nbr,LEN_PIXHDR); + free (pixheader); + fclose (fd); + return (NULL); + } + + /* check pixel header magic word */ + imhver = pix_version (pixheader); + if (imhver < 1) { + (void)fprintf(stderr, "File %s not valid IRAF pixel file.\n", pixname); + free (pixheader); + fclose (fd); + return(NULL); + } + free (pixheader); + + /* Find number of bytes to read */ + hgeti4 (fitsheader,"NAXIS",&naxis); + hgeti4 (fitsheader,"NAXIS1",&naxis1); + hgeti4 (fitsheader,"NAXIS2",&naxis2); + hgeti4 (fitsheader,"NPAXIS1",&npaxis1); + hgeti4 (fitsheader,"NPAXIS2",&npaxis2); + hgeti4 (fitsheader,"BITPIX",&bitpix); + if (bitpix < 0) + bytepix = -bitpix / 8; + else + bytepix = bitpix / 8; + + /* If either dimension is one and image is 3-D, read all three dimensions */ + if (naxis == 3 && ((naxis1 == 1) | (naxis2 == 1))) { + hgeti4 (fitsheader,"NAXIS3",&naxis3); + nbimage = naxis1 * naxis2 * naxis3 * bytepix; + } + else { + nbimage = naxis1 * naxis2 * bytepix; + naxis3 = 1; + } + + if (bytepix > 4) + image = (char *) calloc (nbimage/8, 8); + else if (bytepix > 2) + image = (char *) calloc (nbimage/4, 4); + else if (bytepix > 1) + image = (char *) calloc (nbimage/2, 2); + else + image = (char *) calloc (nbimage, 1); + if (image == NULL) { + (void)fprintf(stderr, "IRAFRIMAGE Cannot allocate %d-byte image buffer\n", + nbimage); + return (NULL); + } + + /* Read IRAF image all at once if physical and image dimensions are the same */ + if (npaxis1 == naxis1) + nbr = fread (image, 1, nbimage, fd); + + /* Read IRAF image one line at a time if physical and image dimensions differ */ + else { + nbdiff = (npaxis1 - naxis1) * bytepix; + nbaxis = naxis1 * bytepix; + linebuff = image; + nbr = 0; + if (naxis2 == 1 && naxis3 > 1) + naxis2 = naxis3; + for (i = 0; i < naxis2; i++) { + nbl = fread (linebuff, 1, nbaxis, fd); + nbr = nbr + nbl; + (void) fseek (fd, nbdiff, SEEK_CUR); + linebuff = linebuff + nbaxis; + } + } + fclose (fd); + + /* Check size of image */ + if (nbr < nbimage) { + (void)fprintf(stderr, "IRAF pixel file %s: %d / %d bytes read.\n", + pixname,nbr,nbimage); + free (image); + return (NULL); + } + + /* Byte-reverse image, if necessary */ + pixswap = 0; + hgetl (fitsheader, "PIXSWAP", &pixswap); + if (pixswap) + irafswap (bitpix, image, nbimage); + + return (image); +} + + +/* Return IRAF image format version number from magic word in IRAF header*/ + +int +head_version (irafheader) + +char *irafheader; /* IRAF image header from file */ + +{ + + /* Check header file magic word */ + if (irafncmp (irafheader, "imhdr", 5) != 0 ) { + if (strncmp (irafheader, "imhv2", 5) != 0) + return (0); + else + return (2); + } + else + return (1); +} + + +/* Return IRAF image format version number from magic word in IRAF pixel file */ + +int +pix_version (irafheader) + +char *irafheader; /* IRAF image header from file */ + +{ + + /* Check pixel file header magic word */ + if (irafncmp (irafheader, "impix", 5) != 0) { + if (strncmp (irafheader, "impv2", 5) != 0) + return (0); + else + return (2); + } + else + return (1); +} + + +/* Verify that file is valid IRAF imhdr or impix by checking first 5 chars + * Returns: 0 on success, 1 on failure */ + +int +irafncmp (irafheader, teststring, nc) + +char *irafheader; /* IRAF image header from file */ +char *teststring; /* C character string to compare */ +int nc; /* Number of characters to compate */ + +{ + char *line; + + headswap = -1; + if ((line = iraf2str (irafheader, nc)) == NULL) + return (1); + if (strncmp (line, teststring, nc) == 0) { + free (line); + return (0); + } + else { + free (line); + return (1); + } +} + +/* Convert IRAF image header to FITS image header, returning FITS header */ + +char * +iraf2fits (hdrname, irafheader, nbiraf, nbfits) + +char *hdrname; /* IRAF header file name (may be path) */ +char *irafheader; /* IRAF image header */ +int nbiraf; /* Number of bytes in IRAF header */ +int *nbfits; /* Number of bytes in FITS header (returned) */ + +{ + char *objname; /* object name from FITS file */ + int lstr, i, j, k, ib, nax, nbits, nl; + int lname = 0; + char *pixname, *newpixname, *bang, *chead; + char *fitsheader; + int nblock, nlines; + char *fhead, *fhead1, *fp, endline[81]; + char irafchar; + char fitsline[81]; + char *dstring; + int pixtype; + int imhver, n, imu, pixoff, impixoff, immax, immin, imtime; + int imndim, imlen, imphyslen, impixtype, pixswap, hpixswap, mtime; + float rmax, rmin; + + headswap = -1; + + /* Set up last line of FITS header */ + (void)strncpy (endline,"END", 3); + for (i = 3; i < 80; i++) + endline[i] = ' '; + endline[80] = 0; + + /* Check header magic word */ + imhver = head_version (irafheader); + if (imhver < 1) { + (void)fprintf(stderr, "File %s not valid IRAF image header\n", + hdrname); + return(NULL); + } + if (imhver == 2) { + nlines = 24 + ((nbiraf - LEN_IM2HDR) / 81); + imndim = IM2_NDIM; + imlen = IM2_LEN; + imphyslen = IM2_PHYSLEN; + impixtype = IM2_PIXTYPE; + impixoff = IM2_PIXOFF; + imtime = IM2_MTIME; + immax = IM2_MAX; + immin = IM2_MIN; + } + else { + nlines = 24 + ((nbiraf - LEN_IMHDR) / 162); + imndim = IM_NDIM; + imlen = IM_LEN; + imphyslen = IM_PHYSLEN; + impixtype = IM_PIXTYPE; + impixoff = IM_PIXOFF; + imtime = IM_MTIME; + immax = IM_MAX; + immin = IM_MIN; + } + + /* Initialize FITS header */ + nblock = (nlines * 80) / 2880; + *nbfits = (nblock + 5) * 2880 + 4; + fitsheader = (char *) calloc (*nbfits, 1); + if (fitsheader == NULL) { + (void)fprintf(stderr, "IRAF2FITS Cannot allocate %d-byte FITS header\n", + *nbfits); + return (NULL); + } + hlength (fitsheader, *nbfits); + fhead = fitsheader; + (void)strncpy (fitsheader, endline, 80); + hputl (fitsheader, "SIMPLE", 1); + fhead = fhead + 80; + + /* Set pixel size in FITS header */ + pixtype = irafgeti4 (irafheader, impixtype); + switch (pixtype) { + case TY_CHAR: + nbits = 8; + break; + case TY_UBYTE: + nbits = 8; + break; + case TY_SHORT: + nbits = 16; + break; + case TY_USHORT: + nbits = -16; + break; + case TY_INT: + case TY_LONG: + nbits = 32; + break; + case TY_REAL: + nbits = -32; + break; + case TY_DOUBLE: + nbits = -64; + break; + default: + (void)fprintf(stderr,"Unsupported data type: %d\n", pixtype); + return (NULL); + } + hputi4 (fitsheader,"BITPIX",nbits); + hputcom (fitsheader,"BITPIX", "IRAF .imh pixel type"); + fhead = fhead + 80; + + /* Set image dimensions in FITS header */ + nax = irafgeti4 (irafheader, imndim); + hputi4 (fitsheader,"NAXIS",nax); + hputcom (fitsheader,"NAXIS", "IRAF .imh naxis"); + fhead = fhead + 80; + + n = irafgeti4 (irafheader, imlen); + hputi4 (fitsheader, "NAXIS1", n); + hputcom (fitsheader,"NAXIS1", "IRAF .imh image naxis[1]"); + fhead = fhead + 80; + + if (nax > 1) { + n = irafgeti4 (irafheader, imlen+4); + hputi4 (fitsheader, "NAXIS2", n); + hputcom (fitsheader,"NAXIS2", "IRAF .imh image naxis[2]"); + } + else + hputi4 (fitsheader, "NAXIS2", 1); + hputcom (fitsheader,"NAXIS2", "IRAF .imh naxis[2]"); + fhead = fhead + 80; + + if (nax > 2) { + n = irafgeti4 (irafheader, imlen+8); + hputi4 (fitsheader, "NAXIS3", n); + hputcom (fitsheader,"NAXIS3", "IRAF .imh image naxis[3]"); + fhead = fhead + 80; + } + if (nax > 3) { + n = irafgeti4 (irafheader, imlen+12); + hputi4 (fitsheader, "NAXIS4", n); + hputcom (fitsheader,"NAXIS4", "IRAF .imh image naxis[4]"); + fhead = fhead + 80; + } + + /* Set object name in FITS header */ + if (imhver == 2) + objname = irafgetc (irafheader, IM2_TITLE, SZ_IM2TITLE); + else + objname = irafgetc2 (irafheader, IM_TITLE, SZ_IMTITLE); + if ((lstr = strlen (objname)) < 8) { + for (i = lstr; i < 8; i++) + objname[i] = ' '; + objname[8] = 0; + } + hputs (fitsheader,"OBJECT",objname); + hputcom (fitsheader,"OBJECT", "IRAF .imh title"); + free (objname); + fhead = fhead + 80; + + /* Save physical axis lengths so image file can be read */ + n = irafgeti4 (irafheader, imphyslen); + hputi4 (fitsheader, "NPAXIS1", n); + hputcom (fitsheader,"NPAXIS1", "IRAF .imh physical naxis[1]"); + fhead = fhead + 80; + if (nax > 1) { + n = irafgeti4 (irafheader, imphyslen+4); + hputi4 (fitsheader, "NPAXIS2", n); + hputcom (fitsheader,"NPAXIS2", "IRAF .imh physical naxis[2]"); + fhead = fhead + 80; + } + if (nax > 2) { + n = irafgeti4 (irafheader, imphyslen+8); + hputi4 (fitsheader, "NPAXIS3", n); + hputcom (fitsheader,"NPAXIS3", "IRAF .imh physical naxis[3]"); + fhead = fhead + 80; + } + if (nax > 3) { + n = irafgeti4 (irafheader, imphyslen+12); + hputi4 (fitsheader, "NPAXIS4", n); + hputcom (fitsheader,"NPAXIS4", "IRAF .imh physical naxis[4]"); + fhead = fhead + 80; + } + + /* Save image minimum and maximum in header */ + rmax = irafgetr4 (irafheader, immax); + rmin = irafgetr4 (irafheader, immin); + if (rmin != rmax) { + hputr4 (fitsheader, "IRAFMIN", &rmin); + fhead = fhead + 80; + hputcom (fitsheader,"IRAFMIN", "IRAF .imh minimum"); + hputr4 (fitsheader, "IRAFMAX", &rmax); + hputcom (fitsheader,"IRAFMAX", "IRAF .imh maximum"); + fhead = fhead + 80; + } + + /* Save image header filename in header */ + nl = hputm (fitsheader,"IMHFIL",hdrname); + if (nl > 0) { + lname = strlen (hdrname); + strcpy (fitsline, "IRAF header file name"); + if (lname < 43) + hputcom (fitsheader,"IMHFIL_1", fitsline); + else if (lname > 67 && lname < 110) + hputcom (fitsheader,"IMHFIL_2", fitsline); + else if (lname > 134 && lname < 177) + hputcom (fitsheader,"IMHFIL_3", fitsline); + } + if (nl > 0) fhead = fhead + (nl * 80); + + /* Save image pixel file pathname in header */ + if (imhver == 2) + pixname = irafgetc (irafheader, IM2_PIXFILE, SZ_IM2PIXFILE); + else + pixname = irafgetc2 (irafheader, IM_PIXFILE, SZ_IMPIXFILE); + if (strncmp(pixname, "HDR", 3) == 0 ) { + newpixname = same_path (pixname, hdrname); + free (pixname); + pixname = newpixname; + } + if (strchr (pixname, '/') == NULL && strchr (pixname, '$') == NULL) { + newpixname = same_path (pixname, hdrname); + free (pixname); + pixname = newpixname; + } + + if ((bang = strchr (pixname, '!')) != NULL ) + nl = hputm (fitsheader,"PIXFIL",bang+1); + else + nl = hputm (fitsheader,"PIXFIL",pixname); + free (pixname); + if (nl > 0) { + strcpy (fitsline, "IRAF .pix pixel file"); + if (lname < 43) + hputcom (fitsheader,"PIXFIL_1", fitsline); + else if (lname > 67 && lname < 110) + hputcom (fitsheader,"PIXFIL_2", fitsline); + else if (lname > 134 && lname < 177) + hputcom (fitsheader,"PIXFIL_3", fitsline); + } + if (nl > 0) fhead = fhead + (nl * 80); + + /* Save image offset from star of pixel file */ + pixoff = irafgeti4 (irafheader, impixoff); + pixoff = (pixoff - 1) * 2; + hputi4 (fitsheader, "PIXOFF", pixoff); + hputcom (fitsheader,"PIXOFF", "IRAF .pix pixel offset (Do not change!)"); + fhead = fhead + 80; + + /* Save IRAF file format version in header */ + hputi4 (fitsheader,"IMHVER",imhver); + hputcom (fitsheader,"IMHVER", "IRAF .imh format version (1 or 2)"); + fhead = fhead + 80; + + /* Set flag if header numbers are byte-reversed on this machine */ + if (machswap() != headswap) + hputl (fitsheader, "HEADSWAP", 1); + else + hputl (fitsheader, "HEADSWAP", 0); + hputcom (fitsheader,"HEADSWAP", "IRAF header, FITS byte orders differ if T"); + fhead = fhead + 80; + + /* Set flag if image pixels are byte-reversed on this machine */ + if (imhver == 2) { + hpixswap = irafgeti4 (irafheader, IM2_SWAPPED); + if (headswap && !hpixswap) + pixswap = 1; + else if (!headswap && hpixswap) + pixswap = 1; + else + pixswap = 0; + } + else + pixswap = headswap; + if (machswap() != pixswap) + hputl (fitsheader, "PIXSWAP", 1); + else + hputl (fitsheader, "PIXSWAP", 0); + hputcom (fitsheader,"PIXSWAP", "IRAF pixels, FITS byte orders differ if T"); + fhead = fhead + 80; + + /* Read modification time */ + mtime = irafgeti4 (irafheader, imtime); + if (mtime == 0) + dstring = lt2fd (); + else + dstring = tsi2fd (mtime); + hputs (fitsheader, "DATE-MOD", dstring); + hputcom (fitsheader,"DATE-MOD", "Date of latest file modification"); + free (dstring); + fhead = fhead + 80; + + /* Add user portion of IRAF header to FITS header */ + fitsline[80] = 0; + if (imhver == 2) { + imu = LEN_IM2HDR; + chead = irafheader; + j = 0; + for (k = 0; k < 80; k++) + fitsline[k] = ' '; + for (i = imu; i < nbiraf; i++) { + irafchar = chead[i]; + if (irafchar == 0) + break; + else if (irafchar == 10) { + (void)strncpy (fhead, fitsline, 80); + /* fprintf (stderr,"%80s\n",fitsline); */ + if (strncmp (fitsline, "OBJECT ", 7) != 0) { + fhead = fhead + 80; + } + for (k = 0; k < 80; k++) + fitsline[k] = ' '; + j = 0; + } + else { + if (j > 80) { + if (strncmp (fitsline, "OBJECT ", 7) != 0) { + (void)strncpy (fhead, fitsline, 80); + /* fprintf (stderr,"%80s\n",fitsline); */ + j = 9; + fhead = fhead + 80; + } + for (k = 0; k < 80; k++) + fitsline[k] = ' '; + } + if (irafchar > 32 && irafchar < 127) + fitsline[j] = irafchar; + j++; + } + } + } + else { + imu = LEN_IMHDR; + chead = irafheader; + if (headswap == 1) + ib = 0; + else + ib = 1; + for (k = 0; k < 80; k++) + fitsline[k] = ' '; + j = 0; + for (i = imu; i < nbiraf; i=i+2) { + irafchar = chead[i+ib]; + if (irafchar == 0) + break; + else if (irafchar == 10) { + if (strncmp (fitsline, "OBJECT ", 7) != 0) { + (void)strncpy (fhead, fitsline, 80); + fhead = fhead + 80; + } + /* fprintf (stderr,"%80s\n",fitsline); */ + j = 0; + for (k = 0; k < 80; k++) + fitsline[k] = ' '; + } + else { + if (j > 80) { + if (strncmp (fitsline, "OBJECT ", 7) != 0) { + (void)strncpy (fhead, fitsline, 80); + j = 9; + fhead = fhead + 80; + } + /* fprintf (stderr,"%80s\n",fitsline); */ + for (k = 0; k < 80; k++) + fitsline[k] = ' '; + } + if (irafchar > 32 && irafchar < 127) + fitsline[j] = irafchar; + j++; + } + } + } + + /* Add END to last line */ + (void)strncpy (fhead, endline, 80); + + /* Find end of last 2880-byte block of header */ + fhead = ksearch (fitsheader, "END") + 80; + nblock = *nbfits / 2880; + fhead1 = fitsheader + (nblock * 2880); + + /* Pad rest of header with spaces */ + strncpy (endline," ",3); + for (fp = fhead; fp < fhead1; fp = fp + 80) { + (void)strncpy (fp, endline,80); + } + + return (fitsheader); +} + + +int +irafwhead (hdrname, lhead, irafheader, fitsheader) + +char *hdrname; /* Name of IRAF header file */ +int lhead; /* Length of IRAF header */ +char *irafheader; /* IRAF header */ +char *fitsheader; /* FITS image header */ + +{ + int fd; + int nbw, nbhead, lphead, pixswap; + + /* Get rid of redundant header information */ + hgeti4 (fitsheader, "PIXOFF", &lphead); + hgeti4 (fitsheader, "PIXSWAP", &pixswap); + + /* Write IRAF header file */ + + /* Convert FITS header to IRAF header */ + irafheader = fits2iraf (fitsheader, irafheader, lhead, &nbhead); + if (irafheader == NULL) { + fprintf (stderr, "IRAFWIMAGE: file %s header error\n", hdrname); + return (-1); + } + + /* Open the output file */ + if (!access (hdrname, 0)) { + fd = open (hdrname, O_WRONLY); + if (fd < 3) { + fprintf (stderr, "IRAFWIMAGE: file %s not writeable\n", hdrname); + return (0); + } + } + else { + fd = open (hdrname, O_RDWR+O_CREAT, 0666); + if (fd < 3) { + fprintf (stderr, "IRAFWIMAGE: cannot create file %s\n", hdrname); + return (0); + } + } + + /* Write IRAF header to disk file */ + nbw = write (fd, irafheader, nbhead); + (void) ftruncate (fd, nbhead); + close (fd); + if (nbw < nbhead) { + (void)fprintf(stderr, "IRAF header file %s: %d / %d bytes written.\n", + hdrname, nbw, nbhead); + return (-1); + } + + return (nbw); +} + +/* IRAFWIMAGE -- write IRAF .imh header file and .pix image file + * No matter what the input, this always writes in the local byte order */ + +int +irafwimage (hdrname, lhead, irafheader, fitsheader, image ) + +char *hdrname; /* Name of IRAF header file */ +int lhead; /* Length of IRAF header */ +char *irafheader; /* IRAF header */ +char *fitsheader; /* FITS image header */ +char *image; /* IRAF image */ + +{ + int fd; + char *bang; + int nbw, bytepix, bitpix, naxis, naxis1, naxis2, nbimage, lphead; + char *pixn, *newpixname; + char pixname[SZ_IM2PIXFILE+1]; + int imhver, pixswap; + + hgeti4 (fitsheader, "IMHVER", &imhver); + + if (!hgetm (fitsheader, "PIXFIL", SZ_IM2PIXFILE, pixname)) { + if (imhver == 2) + pixn = irafgetc (irafheader, IM2_PIXFILE, SZ_IM2PIXFILE); + else + pixn = irafgetc2 (irafheader, IM_PIXFILE, SZ_IMPIXFILE); + if (strncmp(pixn, "HDR", 3) == 0 ) { + newpixname = same_path (pixn, hdrname); + strcpy (pixname, newpixname); + free (newpixname); + } + else { + if ((bang = strchr (pixn, '!')) != NULL ) + strcpy (pixname, bang+1); + else + strcpy (pixname, pixn); + } + free (pixn); + } + + /* Find number of bytes to write */ + hgeti4 (fitsheader,"NAXIS",&naxis); + hgeti4 (fitsheader,"NAXIS1",&naxis1); + hgeti4 (fitsheader,"NAXIS2",&naxis2); + hgeti4 (fitsheader,"BITPIX",&bitpix); + if (bitpix < 0) + bytepix = -bitpix / 8; + else + bytepix = bitpix / 8; + + /* If either dimension is one and image is 3-D, read all three dimensions */ + if (naxis == 3 && ((naxis1 == 1) | (naxis2 == 1))) { + int naxis3; + hgeti4 (fitsheader,"NAXIS3",&naxis3); + nbimage = naxis1 * naxis2 * naxis3 * bytepix; + } + else + nbimage = naxis1 * naxis2 * bytepix; + + /* Read information about pixel file from header */ + hgeti4 (fitsheader, "PIXOFF", &lphead); + hgeti4 (fitsheader, "PIXSWAP", &pixswap); + + /* Write IRAF header file */ + if (irafwhead (hdrname, lhead, irafheader, fitsheader)) + return (0); + + /* Open the output file */ + if (!access (pixname, 0)) { + fd = open (pixname, O_WRONLY); + if (fd < 3) { + fprintf (stderr, "IRAFWIMAGE: file %s not writeable\n", pixname); + return (0); + } + } + else { + fd = open (pixname, O_RDWR+O_CREAT, 0666); + if (fd < 3) { + fprintf (stderr, "IRAFWIMAGE: cannot create file %s\n", pixname); + return (0); + } + } + + /* Write header to IRAF pixel file */ + if (imhver == 2) + irafputc ("impv2", irafheader, 0, 5); + else + irafputc2 ("impix", irafheader, 0, 5); + nbw = write (fd, irafheader, lphead); + + /* Byte-reverse image, if necessary */ + if (pixswap) + irafswap (bitpix, image, nbimage); + + /* Write data to IRAF pixel file */ + nbw = write (fd, image, nbimage); + close (fd); + + return (nbw); +} + + +/* Put filename and header path together */ + +static char * +same_path (pixname, hdrname) + +char *pixname; /* IRAF pixel file pathname */ +char *hdrname; /* IRAF image header file pathname */ + +{ + int len, plen; + char *newpixname; + + newpixname = (char *) calloc (SZ_IM2PIXFILE, 1); + + /* Pixel file is in same directory as header */ + if (strncmp(pixname, "HDR$", 4) == 0 ) { + (void)strncpy (newpixname, hdrname, SZ_IM2PIXFILE); + + /* find the end of the pathname */ + len = strlen (newpixname); +#ifndef VMS + while( (len > 0) && (newpixname[len-1] != '/') ) +#else + while( (len > 0) && (newpixname[len-1] != ']') && (newpixname[len-1] != ':') ) +#endif + len--; + + /* add name */ + newpixname[len] = '\0'; + plen = strlen (pixname) - 4; + if (len + plen > SZ_IM2PIXFILE) + (void)strncat (newpixname, &pixname[4], SZ_IM2PIXFILE - len); + else + (void)strncat (newpixname, &pixname[4], plen); + } + + /* Bare pixel file with no path is assumed to be same as HDR$filename */ + else if (strchr (pixname, '/') == NULL && strchr (pixname, '$') == NULL) { + (void)strncpy (newpixname, hdrname, SZ_IM2PIXFILE); + + /* find the end of the pathname */ + len = strlen (newpixname); +#ifndef VMS + while( (len > 0) && (newpixname[len-1] != '/') ) +#else + while( (len > 0) && (newpixname[len-1] != ']') && (newpixname[len-1] != ':') ) +#endif + len--; + + /* add name */ + newpixname[len] = '\0'; + (void)strncat (newpixname, pixname, SZ_IM2PIXFILE); + } + + /* Pixel file has same name as header file, but with .pix extension */ + else if (strncmp (pixname, "HDR", 3) == 0) { + + /* load entire header name string into name buffer */ + (void)strncpy (newpixname, hdrname, SZ_IM2PIXFILE); + len = strlen (newpixname); + newpixname[len-3] = 'p'; + newpixname[len-2] = 'i'; + newpixname[len-1] = 'x'; + } + + return (newpixname); +} + +/* Convert FITS image header to IRAF image header, returning IRAF header */ +/* No matter what the input, this always writes in the local byte order */ + +char * +fits2iraf (fitsheader, irafheader, nbhead, nbiraf) + +char *fitsheader; /* FITS image header */ +char *irafheader; /* IRAF image header (returned updated) */ +int nbhead; /* Length of IRAF header */ +int *nbiraf; /* Length of returned IRAF header */ + +{ + int i, n, pixoff, lhdrdir; + short *irafp, *irafs, *irafu; + char *iraf2u, *iraf2p, *filename, *hdrdir; + char *fitsend, *fitsp, pixfile[SZ_IM2PIXFILE], hdrfile[SZ_IM2HDRFILE]; + char title[SZ_IM2TITLE], temp[80]; + int nax, nlfits, imhver, nbits, pixtype, hdrlength, mtime; + int imndim, imlen, imphyslen, impixtype, imhlen, imtime, immax, immin; + float rmax, rmin; + + hgeti4 (fitsheader, "IMHVER", &imhver); + hdel (fitsheader, "IMHVER"); + hdel (fitsheader, "IMHVER"); + hgetl (fitsheader, "HEADSWAP", &headswap); + hdel (fitsheader, "HEADSWAP"); + hdel (fitsheader, "HEADSWAP"); + if (imhver == 2) { + imhlen = IM2_HDRLEN; + imndim = IM2_NDIM; + imlen = IM2_LEN; + imtime = IM2_MTIME; + imphyslen = IM2_PHYSLEN; + impixtype = IM2_PIXTYPE; + immax = IM2_MAX; + immin = IM2_MIN; + } + else { + imhlen = IM_HDRLEN; + imndim = IM_NDIM; + imlen = IM_LEN; + imtime = IM_MTIME; + imphyslen = IM_PHYSLEN; + impixtype = IM_PIXTYPE; + immax = IM_MAX; + immin = IM_MIN; + } + + /* Delete FITS header keyword not needed by IRAF */ + hdel (fitsheader,"SIMPLE"); + + /* Set IRAF image data type */ + hgeti4 (fitsheader,"BITPIX", &nbits); + switch (nbits) { + case 8: + pixtype = TY_CHAR; + break; + case -8: + pixtype = TY_UBYTE; + break; + case 16: + pixtype = TY_SHORT; + break; + case -16: + pixtype = TY_USHORT; + break; + case 32: + pixtype = TY_INT; + break; + case -32: + pixtype = TY_REAL; + break; + case -64: + pixtype = TY_DOUBLE; + break; + default: + (void)fprintf(stderr,"Unsupported data type: %d\n", nbits); + return (NULL); + } + irafputi4 (irafheader, impixtype, pixtype); + hdel (fitsheader,"BITPIX"); + + /* Set IRAF image dimensions */ + hgeti4 (fitsheader,"NAXIS",&nax); + irafputi4 (irafheader, imndim, nax); + hdel (fitsheader,"NAXIS"); + + hgeti4 (fitsheader, "NAXIS1", &n); + irafputi4 (irafheader, imlen, n); + irafputi4 (irafheader, imphyslen, n); + hdel (fitsheader,"NAXIS1"); + + hgeti4 (fitsheader,"NAXIS2",&n); + irafputi4 (irafheader, imlen+4, n); + irafputi4 (irafheader, imphyslen+4, n); + hdel (fitsheader,"NAXIS2"); + + if (nax > 2) { + hgeti4 (fitsheader,"NAXIS3",&n); + irafputi4 (irafheader, imlen+8, n); + irafputi4 (irafheader, imphyslen+8, n); + hdel (fitsheader,"NAXIS3"); + } + + if (nax > 3) { + hgeti4 (fitsheader,"NAXIS4",&n); + irafputi4 (irafheader, imlen+12, n); + irafputi4 (irafheader, imphyslen+12, n); + hdel (fitsheader,"NAXIS4"); + } + + /* Set image pixel value limits */ + rmin = 0.0; + hgetr4 (fitsheader, "IRAFMIN", &rmin); + rmax = 0.0; + hgetr4 (fitsheader, "IRAFMAX", &rmax); + if (rmin != rmax) { + irafputr4 (irafheader, immax, rmax); + irafputr4 (irafheader, immin, rmin); + } + hdel (fitsheader, "IRAFMIN"); + hdel (fitsheader, "IRAFMAX"); + + /* Replace pixel file name, if it is in the FITS header */ + if (hgetm (fitsheader, "PIXFIL", SZ_IM2PIXFILE, pixfile)) { + if (strchr (pixfile, '/')) { + if (hgetm (fitsheader, "IMHFIL", SZ_IM2HDRFILE, hdrfile)) { + hdrdir = strrchr (hdrfile, '/'); + if (hdrdir != NULL) { + lhdrdir = hdrdir - hdrfile + 1; + if (!strncmp (pixfile, hdrfile, lhdrdir)) { + filename = pixfile + lhdrdir; + strcpy (temp, "HDR$"); + strcat (temp,filename); + strcpy (pixfile, temp); + } + } + if (pixfile[0] != '/' && pixfile[0] != 'H') { + strcpy (temp, "HDR$"); + strcat (temp,pixfile); + strcpy (pixfile, temp); + } + } + } + + if (imhver == 2) + irafputc (pixfile, irafheader, IM2_PIXFILE, SZ_IM2PIXFILE); + else + irafputc2 (pixfile, irafheader, IM_PIXFILE, SZ_IMPIXFILE); + hdel (fitsheader,"PIXFIL_1"); + hdel (fitsheader,"PIXFIL_2"); + hdel (fitsheader,"PIXFIL_3"); + hdel (fitsheader,"PIXFIL_4"); + } + + /* Replace header file name, if it is in the FITS header */ + if (hgetm (fitsheader, "IMHFIL", SZ_IM2HDRFILE, pixfile)) { + if (!strchr (pixfile,'/') && !strchr (pixfile,'$')) { + strcpy (temp, "HDR$"); + strcat (temp,pixfile); + strcpy (pixfile, temp); + } + if (imhver == 2) + irafputc (pixfile, irafheader, IM2_HDRFILE, SZ_IM2HDRFILE); + else + irafputc2 (pixfile, irafheader, IM_HDRFILE, SZ_IMHDRFILE); + hdel (fitsheader, "IMHFIL_1"); + hdel (fitsheader, "IMHFIL_2"); + hdel (fitsheader, "IMHFIL_3"); + hdel (fitsheader, "IMHFIL_4"); + } + + /* Replace image title, if it is in the FITS header */ + if (hgets (fitsheader, "OBJECT", SZ_IM2TITLE, title)) { + if (imhver == 2) + irafputc (title, irafheader, IM2_TITLE, SZ_IM2TITLE); + else + irafputc2 (title, irafheader, IM_TITLE, SZ_IMTITLE); + hdel (fitsheader, "OBJECT"); + } + hgeti4 (fitsheader, "PIXOFF", &pixoff); + hdel (fitsheader, "PIXOFF"); + hdel (fitsheader, "PIXOFF"); + hdel (fitsheader, "PIXSWAP"); + hdel (fitsheader, "PIXSWAP"); + hdel (fitsheader, "DATE-MOD"); + hdel (fitsheader, "DATE-MOD"); + fitsend = ksearch (fitsheader,"END"); + + /* Find length of FITS header */ + fitsend = ksearch (fitsheader,"END"); + nlfits = ((fitsend - fitsheader) / 80); + + /* Find new length of IRAF header */ + if (imhver == 2) + *nbiraf = LEN_IM2HDR + (81 * nlfits); + else + *nbiraf = LEN_IMHDR + (162 * nlfits); + if (*nbiraf > nbhead) + irafheader = realloc (irafheader, *nbiraf); + + /* Reset modification time */ + mtime = lt2tsi (); + irafputi4 (irafheader, imtime, mtime); + + /* Replace user portion of IRAF header with remaining FITS header */ + if (imhver == 2) { + iraf2u = irafheader + LEN_IM2HDR; + iraf2p = iraf2u; + for (fitsp = fitsheader; fitsp < fitsend; fitsp = fitsp + 80) { + for (i = 0; i < 80; i++) + *iraf2p++ = fitsp[i]; + *iraf2p++ = 10; + } + *iraf2p++ = 0; + *nbiraf = iraf2p - irafheader; + hdrlength = 1 + *nbiraf / 2; + } + else { + irafs = (short *)irafheader; + irafu = irafs + (LEN_IMHDR / 2); + irafp = irafu; + for (fitsp = fitsheader; fitsp < fitsend; fitsp = fitsp + 80) { + for (i = 0; i < 80; i++) + *irafp++ = (short) fitsp[i]; + *irafp++ = 10; + } + *irafp++ = 0; + *irafp++ = 32; + *nbiraf = 2 * (irafp - irafs); + hdrlength = *nbiraf / 4; + } + + /* Length of header file */ + irafputi4 (irafheader, imhlen, hdrlength); + + /* Offset in .pix file to first pixel data + hputi4 (fitsheader, "PIXOFF", pixoff); */ + + /* Return number of bytes in new IRAF header */ + return (irafheader); +} + + +int +irafgeti4 (irafheader, offset) + +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before number */ + +{ + char *ctemp, *cheader; + int temp; + + cheader = irafheader; + ctemp = (char *) &temp; + + /* If header swap flag not set, set it now */ + if (headswap < 0) { + if (cheader[offset] > 0) + headswap = 1; + else + headswap = 0; + } + + if (machswap() != headswap) { + ctemp[3] = cheader[offset]; + ctemp[2] = cheader[offset+1]; + ctemp[1] = cheader[offset+2]; + ctemp[0] = cheader[offset+3]; + } + else { + ctemp[0] = cheader[offset]; + ctemp[1] = cheader[offset+1]; + ctemp[2] = cheader[offset+2]; + ctemp[3] = cheader[offset+3]; + } + return (temp); +} + + +float +irafgetr4 (irafheader, offset) + +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before number */ + +{ + char *ctemp, *cheader; + float temp; + + cheader = irafheader; + ctemp = (char *) &temp; + + /* If header swap flag not set, set it now */ + if (headswap < 0) { + if (cheader[offset] > 0) + headswap = 1; + else + headswap = 0; + } + + if (machswap() != headswap) { + ctemp[3] = cheader[offset]; + ctemp[2] = cheader[offset+1]; + ctemp[1] = cheader[offset+2]; + ctemp[0] = cheader[offset+3]; + } + else { + ctemp[0] = cheader[offset]; + ctemp[1] = cheader[offset+1]; + ctemp[2] = cheader[offset+2]; + ctemp[3] = cheader[offset+3]; + } + return (temp); +} + + +/* IRAFGETC2 -- Get character string from arbitrary part of v.1 IRAF header */ + +char * +irafgetc2 (irafheader, offset, nc) + +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before string */ +int nc; /* Maximum number of characters in string */ + +{ + char *irafstring, *string; + + irafstring = irafgetc (irafheader, offset, 2*(nc+1)); + string = iraf2str (irafstring, nc); + free (irafstring); + + return (string); +} + + +/* IRAFGETC -- Get character string from arbitrary part of IRAF header */ + +char * +irafgetc (irafheader, offset, nc) + +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before string */ +int nc; /* Maximum number of characters in string */ + +{ + char *ctemp, *cheader; + int i; + + cheader = irafheader; + ctemp = (char *) calloc (nc+1, 1); + if (ctemp == NULL) { + (void)fprintf(stderr, "IRAFGETC Cannot allocate %d-byte variable\n", + nc+1); + return (NULL); + } + for (i = 0; i < nc; i++) { + ctemp[i] = cheader[offset+i]; + if (ctemp[i] > 0 && ctemp[i] < 32) + ctemp[i] = ' '; + } + + return (ctemp); +} + + +/* Convert IRAF 2-byte/char string to 1-byte/char string */ + +char * +iraf2str (irafstring, nchar) + +char *irafstring; /* IRAF 2-byte/character string */ +int nchar; /* Number of characters in string */ +{ + char *string; + int i, j; + + /* Set swap flag according to position of nulls in 2-byte characters */ + if (headswap < 0) { + if (irafstring[0] != 0 && irafstring[1] == 0) + headswap = 1; + else if (irafstring[0] == 0 && irafstring[1] != 0) + headswap = 0; + else + return (NULL); + } + + string = (char *) calloc (nchar+1, 1); + if (string == NULL) { + (void)fprintf(stderr, "IRAF2STR Cannot allocate %d-byte variable\n", + nchar+1); + return (NULL); + } + + /* Swap bytes, if requested */ + if (headswap) + j = 0; + else + j = 1; + + /* Convert appropriate byte of input to output character */ + for (i = 0; i < nchar; i++) { + string[i] = irafstring[j]; + j = j + 2; + } + + return (string); +} + + +/* IRAFPUTI4 -- Insert 4-byte integer into arbitrary part of IRAF header */ + +static void +irafputi4 (irafheader, offset, inum) + +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before number */ +int inum; /* Number to put into header */ + +{ + char *cn, *chead; + + chead = irafheader; + cn = (char *) &inum; + if (headswap < 0) + headswap = 0; + if (headswap != machswap()) { + chead[offset+3] = cn[0]; + chead[offset+2] = cn[1]; + chead[offset+1] = cn[2]; + chead[offset] = cn[3]; + } + else { + chead[offset] = cn[0]; + chead[offset+1] = cn[1]; + chead[offset+2] = cn[2]; + chead[offset+3] = cn[3]; + } + return; +} + + +/* IRAFPUTR4 -- Insert 4-byte real number into arbitrary part of IRAF header */ + +static void +irafputr4 (irafheader, offset, rnum) + +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before number */ +float rnum; /* Number to put into header */ + +{ + char *cn, *chead; + + chead = irafheader; + cn = (char *) &rnum; + if (headswap < 0) + headswap = 0; + if (headswap != machswap()) { + chead[offset+3] = cn[0]; + chead[offset+2] = cn[1]; + chead[offset+1] = cn[2]; + chead[offset] = cn[3]; + } + else { + chead[offset] = cn[0]; + chead[offset+1] = cn[1]; + chead[offset+2] = cn[2]; + chead[offset+3] = cn[3]; + } + return; +} + + +/* IRAFPUTC2 -- Insert character string into arbitrary part of v.1 IRAF header */ + +static void +irafputc2 (string, irafheader, offset, nc) + +char *string; /* String to insert into header */ +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before string */ +int nc; /* Maximum number of characters in string */ + +{ + char *irafstring; + + irafstring = (char *) calloc (2 * nc, 1); + if (irafstring == NULL) { + (void)fprintf(stderr, "IRAFPUTC2 Cannot allocate %d-byte variable\n", + 2 * nc); + } + str2iraf (string, irafstring, nc); + irafputc (irafstring, irafheader, offset, 2*nc); + + return; +} + + +/* IRAFPUTC -- Insert character string into arbitrary part of IRAF header */ + +static void +irafputc (string, irafheader, offset, nc) + +char *string; /* String to insert into header */ +char *irafheader; /* IRAF image header */ +int offset; /* Number of bytes to skip before string */ +int nc; /* Maximum number of characters in string */ + +{ + char *chead; + int i; + + chead = irafheader; + for (i = 0; i < nc; i++) + chead[offset+i] = string[i]; + + return; +} + + +/* STR2IRAF -- Convert 1-byte/char string to IRAF 2-byte/char string */ + +static void +str2iraf (string, irafstring, nchar) + +char *string; /* 1-byte/character string */ +char *irafstring; /* IRAF 2-byte/character string */ +int nchar; /* Maximum number of characters in IRAF string */ +{ + int i, j, nc, nbytes; + + nc = strlen (string); + + /* Fill output string with zeroes */ + nbytes = nchar * 2; + for (i = 0; i < nbytes; i++) + irafstring[i] = 0; + + /* If swapped, start with first byte of 2-byte characters */ + if (headswap) + j = 0; + else + j = 1; + + /* Move input characters to appropriate bytes of output */ + for (i = 0; i < nchar; i++) { + if (i > nc) + irafstring[j] = 0; + else + irafstring[j] = string[i]; + j = j + 2; + } + + return; +} + + +/* IRAFSWAP -- Reverse bytes of any type of vector in place */ + +static void +irafswap (bitpix, string, nbytes) + +int bitpix; /* Number of bits per pixel */ + /* 16 = short, -16 = unsigned short, 32 = int */ + /* -32 = float, -64 = double */ +char *string; /* Address of starting point of bytes to swap */ +int nbytes; /* Number of bytes to swap */ + +{ + switch (bitpix) { + + case 16: + if (nbytes < 2) return; + irafswap2 (string,nbytes); + break; + + case 32: + if (nbytes < 4) return; + irafswap4 (string,nbytes); + break; + + case -16: + if (nbytes < 2) return; + irafswap2 (string,nbytes); + break; + + case -32: + if (nbytes < 4) return; + irafswap4 (string,nbytes); + break; + + case -64: + if (nbytes < 8) return; + irafswap8 (string,nbytes); + break; + + } + return; +} + + +/* IRAFSWAP2 -- Swap bytes in string in place */ + +static void +irafswap2 (string,nbytes) + + +char *string; /* Address of starting point of bytes to swap */ +int nbytes; /* Number of bytes to swap */ + +{ + char *sbyte, temp, *slast; + + slast = string + nbytes; + sbyte = string; + while (sbyte < slast) { + temp = sbyte[0]; + sbyte[0] = sbyte[1]; + sbyte[1] = temp; + sbyte= sbyte + 2; + } + return; +} + + +/* IRAFSWAP4 -- Reverse bytes of Integer*4 or Real*4 vector in place */ + +static void +irafswap4 (string,nbytes) + +char *string; /* Address of Integer*4 or Real*4 vector */ +int nbytes; /* Number of bytes to reverse */ + +{ + char *sbyte, *slast; + char temp0, temp1, temp2, temp3; + + slast = string + nbytes; + sbyte = string; + while (sbyte < slast) { + temp3 = sbyte[0]; + temp2 = sbyte[1]; + temp1 = sbyte[2]; + temp0 = sbyte[3]; + sbyte[0] = temp0; + sbyte[1] = temp1; + sbyte[2] = temp2; + sbyte[3] = temp3; + sbyte = sbyte + 4; + } + + return; +} + + +/* IRAFSWAP8 -- Reverse bytes of Real*8 vector in place */ + +static void +irafswap8 (string,nbytes) + +char *string; /* Address of Real*8 vector */ +int nbytes; /* Number of bytes to reverse */ + +{ + char *sbyte, *slast; + char temp[8]; + + slast = string + nbytes; + sbyte = string; + while (sbyte < slast) { + temp[7] = sbyte[0]; + temp[6] = sbyte[1]; + temp[5] = sbyte[2]; + temp[4] = sbyte[3]; + temp[3] = sbyte[4]; + temp[2] = sbyte[5]; + temp[1] = sbyte[6]; + temp[0] = sbyte[7]; + sbyte[0] = temp[0]; + sbyte[1] = temp[1]; + sbyte[2] = temp[2]; + sbyte[3] = temp[3]; + sbyte[4] = temp[4]; + sbyte[5] = temp[5]; + sbyte[6] = temp[6]; + sbyte[7] = temp[7]; + sbyte = sbyte + 8; + } + return; +} + + +/* Set flag if machine on which program is executing is not FITS byte order + * ( i.e., if it is an Alpha or PC instead of a Sun ) */ + +static int +machswap () + +{ + char *ctest; + int itest; + + itest = 1; + ctest = (char *)&itest; + if (*ctest) + return (1); + else + return (0); +} + + +/* ISIRAF -- return 1 if IRAF imh file, else 0 */ + +int +isiraf (filename) + +char *filename; /* Name of file for which to find size */ +{ + if (strchr (filename, '=')) + return (0); + else if (strsrch (filename, ".imh")) + return (1); + else + return (0); +} + + +/* IRAFSIZE -- return size of file in bytes */ + +static int +irafsize (diskfile) + +FILE *diskfile; /* Descriptor of file for which to find size */ +{ + long filesize; + long offset; + + offset = (long) 0; + + /* Move to end of the file */ + if (fseek (diskfile, offset, SEEK_END) == 0) { + + /* Position is the size of the file */ + filesize = ftell (diskfile); + + /* Move file pointer back tot he start of the file */ + fseek (diskfile, offset, SEEK_SET); + } + + else + filesize = -1; + + return (filesize); +} + +/* Feb 15 1996 New file + * Apr 10 1996 Add more documentation + * Apr 17 1996 Print error message on open failure + * Jun 5 1996 Add byte swapping (reversal); use streams + * Jun 10 1996 Make fixes after running lint + * Jun 12 1996 Use IMSWAP subroutines instead of local ones + * Jul 3 1996 Go back to using local IRAFSWAP subroutines + * Jul 3 1996 Write to pixel file from FITS header + * Jul 10 1996 Allocate all headers + * Aug 13 1996 Add unistd.h to include list + * Aug 26 1996 Allow 1-d images; fix comments; fix arguments after lint + * Aug 26 1996 Add IRAF header lingth argument to IRAFWIMAGE and IRAFWHEAD + * Aug 28 1996 Clean up code in IRAF2FITS + * Aug 30 1996 Use write instead of fwrite + * Sep 4 1996 Fix write mode bug + * Oct 15 1996 Drop unused variables + * Oct 17 1996 Minor fix after lint; cast arguments to STR2IRAF + * + * May 15 1997 Fix returned header length in IRAF2FITS + * Dec 19 1997 Add IRAF version 2 .imh files + * + * Jan 2 1998 Allow uneven length of user parameter lines in IRAF headers + * Jan 6 1998 Fix output of imh2 headers; allow newlines in imh1 headers + * Jan 14 1998 Handle byte reversing correctly + * Apr 17 1998 Add new IRAF data types unsigned char and unsigned short + * Apr 30 1998 Fix error return if illegal data type after Allan Brighton + * May 15 1998 Delete header keywords used for IRAF binary values + * May 15 1998 Fix bug so FITS OBJECT is put into IRAF title + * May 26 1998 Fix bug in fits2iraf keeping track of end of header + * May 27 1998 Include fitsio.h instead of fitshead.h + * Jun 4 1998 Write comments into header for converted IRAF binary values + * Jun 4 1998 Pad FITS strings to 8 character minimum + * Jul 24 1998 Write header file length to IRAF header file + * Jul 27 1998 Print error messages to stderr for all failed malloc's + * Jul 27 1998 Fix bug padding FITS header with spaces in iraf2fits + * Jul 27 1998 Write modification time to IRAF header file + * Aug 6 1998 Change fitsio.h to fitsfile.h; imhio.c to imhfile.c + * Oct 1 1998 Set irafswap flag only once per file + * Oct 5 1998 Add subroutines irafsize() and isiraf() + * Nov 16 1998 Fix byte-swap checking + * + * Jan 27 1999 Read and write all of 3D image if one dimension is =1 + * Jul 13 1999 Improve error messages; change irafsize() argument to fd + * Sep 22 1999 Don't copy OBJECT keyword from .imh file; use binary title + * Oct 14 1999 Set FITS header length + * Oct 20 1999 Allocate 5000 extra bytes for IRAF header + * Nov 2 1999 Fix getclocktime() to use only time.h subroutines + * Nov 2 1999 Add modification date and time to FITS header in iraf2fits() + * Nov 24 1999 Delete HEADSWAP, IMHVER, DATE-MOD from header before writing + * Nov 29 1999 Delete PIXSWAP, IRAF-MIN, IRAF-MAX from header before writing + * + * Jan 13 2000 Fix bug which dropped characters in iraf2fits() + * Feb 3 2000 Declare timezone long, not time_t; drop unused variable + * Mar 7 2000 Add more code to keep pixel file path short + * Mar 10 2000 Fix bugs when writing .imh file headers + * Mar 21 2000 Change computation of IRAF time tags to use only data structure + * Mar 22 2000 Move IRAF time tag computation to lt2tsi() in dateutil.c + * Mar 24 2000 Use Unix file update time if none in header + * Mar 27 2000 Use hputm() to save file paths up to 256 characters + * Mar 27 2000 Write filename comments after 1st keyword with short value + * Mar 27 2000 Allocate pixel file name in same_path to imh2 length + * Mar 29 2000 Add space after last linefeed of header in fits2iraf() + * Apr 28 2000 Dimension pixname in irafwimage() + * May 1 2000 Fix code for updating pixel file name with HDR$ in fits2iraf() + * Jun 2 2000 Drop unused variables in fits2iraf() after lint + * Jun 12 2000 If pixel filename has no / or $, use same path as header file + * Sep 6 2000 Use header directory if pixel file not found at its pathname + * + * Jan 11 2001 Print all messages to stderr + * Aug 24 2001 In isiraf(), return 0 if argument contains an equal sign + * + * Apr 8 2002 Fix bug in error message for unidentified nbits in fits2iraf() + * + * Feb 4 2003 Open catalog file rb instead of r (Martin Ploner, Bern) + * Oct 31 2003 Read image only in irafrimage() if physical dimension > image dim. + * Nov 3 2003 Set NAXISi to image, not physical dimensions in iraf2fits() + * + * Jun 13 2005 Drop trailing spaces on pixel file name + * + * Jun 20 2006 Initialize uninitialized variables + * + * Jan 4 2007 Change hputr4() calls to send pointer to value + * Jan 8 2007 Drop unused variable nbx in irafrimage() + * Jan 8 2007 Align header and image buffers properly by 4 and by BITPIX + * + * May 20 2011 Free newpixname, not pixname in irafwimage() + * + * Mar 27 2012 Fix pixname's appending to newpixname to avoid overflow + */ |