/*--------------------------------------------------------------------------*/
int ffikey(fitsfile *fptr, /* I - FITS file pointer */
char *card, /* I - card string value */
int *status) /* IO - error status */
/*
insert a keyword at the position of fptr->nextkey
*/
{
int nshift;
size_t ii, len;
long nblocks, bytepos;
char *inbuff, *outbuff, *tmpbuff, buff1[80], buff2[80];
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if ( (fptr->datastart - fptr->headend) == 80) /* only room for END card */
{
nblocks = 1;
if (ffiblk(fptr, nblocks, 0, status) > 0) /* add new 2880-byte block*/
return(*status);
}
nshift=( fptr->headend - fptr->nextkey ) / 80; /* no. keywords to shift */
strncpy(buff2, card, 80); /* copy card to output buffer */
len = strlen(buff2);
for (ii=len; ii < 80; ii++) /* fill buffer with spaces if necessary */
buff2[ii] = ' ';
inbuff = buff1;
outbuff = buff2;
bytepos = fptr->nextkey; /* pointer to next keyword in header */
ffmbyt(fptr, bytepos, REPORT_EOF, status);
for (ii = 0; ii < nshift; ii++) /* shift each keyword down one position */
{
ffgbyt(fptr, 80, inbuff, status); /* read the current keyword */
ffmbyt(fptr, bytepos, REPORT_EOF, status); /* move back */
ffpbyt(fptr, 80, outbuff, status); /* overwrite with other buffer */
tmpbuff = inbuff; /* swap input and output buffers */
inbuff = outbuff;
outbuff = tmpbuff;
bytepos += 80;
}
ffpbyt(fptr, 80, outbuff, status); /* write the final keyword */
fptr->headend += 80; /* increment the position of the END keyword */
fptr->nextkey += 80; /* increment the pointer to next keyword */
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffcpdt(fitsfile *infptr, /* I - FITS file pointer to input file */
fitsfile *outfptr, /* I - FITS file pointer to output file */
int *status) /* IO - error status */
{
/*
copy the data unit from the CHDU of infptr to the CHDU of outfptr.
This will overwrite any data already in the outfptr CHDU.
*/
long nb, ii;
LONGLONG indatastart, indataend, outdatastart;
char buffer[2880];
if (*status > 0)
return(*status);
if (infptr == outfptr)
return(*status = SAME_FILE);
ffghadll(infptr, NULL, &indatastart, &indataend, status);
ffghadll(outfptr, NULL, &outdatastart, NULL, status);
/* Calculate the number of blocks to be copied */
nb = (long) ((indataend - indatastart) / 2880);
if (nb > 0)
{
if (infptr->Fptr == outfptr->Fptr)
{
/* copying between 2 HDUs in the SAME file */
for (ii = 0; ii < nb; ii++)
{
ffmbyt(infptr, indatastart, REPORT_EOF, status);
ffgbyt(infptr, 2880L, buffer, status); /* read input block */
ffmbyt(outfptr, outdatastart, IGNORE_EOF, status);
ffpbyt(outfptr, 2880L, buffer, status); /* write output block */
indatastart += 2880; /* move address */
outdatastart += 2880; /* move address */
}
}
else
{
/* copying between HDUs in separate files */
/* move to the initial copy position in each of the files */
ffmbyt(infptr, indatastart, REPORT_EOF, status);
ffmbyt(outfptr, outdatastart, IGNORE_EOF, status);
for (ii = 0; ii < nb; ii++)
{
ffgbyt(infptr, 2880L, buffer, status); /* read input block */
ffpbyt(outfptr, 2880L, buffer, status); /* write output block */
}
}
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpextn( fitsfile *fptr, /* I - FITS file pointer */
LONGLONG offset, /* I - byte offset from start of extension data */
LONGLONG nelem, /* I - number of elements to write */
void *buffer, /* I - stream of bytes to write */
int *status) /* IO - error status */
/*
Write a stream of bytes to the current FITS HDU. This primative routine is mainly
for writing non-standard "conforming" extensions and should not be used
for standard IMAGE, TABLE or BINTABLE extensions.
*/
{
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* reset position to the correct HDU if necessary */
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
/* rescan header if data structure is undefined */
else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
if ( ffrdef(fptr, status) > 0)
return(*status);
/* move to write position */
ffmbyt(fptr, (fptr->Fptr)->datastart+ offset, IGNORE_EOF, status);
/* write the buffer */
ffpbyt(fptr, nelem, buffer, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffdrec(fitsfile *fptr, /* I - FITS file pointer */
int keypos, /* I - position in header of keyword to delete */
int *status) /* IO - error status */
/*
Delete a header keyword at position keypos. The 1st keyword is at keypos=1.
*/
{
int ii, nshift;
long bytepos;
char *inbuff, *outbuff, *tmpbuff, buff1[81], buff2[81];
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if (keypos < 1 ||
keypos > fptr->headend - fptr->headstart[fptr->curhdu] / 80 )
return(*status = KEY_OUT_BOUNDS);
fptr->nextkey = fptr->headstart[fptr->curhdu] + (keypos - 1) * 80;
nshift=( fptr->headend - fptr->nextkey ) / 80; /* no. keywords to shift */
bytepos = fptr->headend - 80; /* last keyword in header */
/* construct a blank keyword */
strcpy(buff2, " ");
strcat(buff2, " ");
inbuff = buff1;
outbuff = buff2;
for (ii = 0; ii < nshift; ii++) /* shift each keyword up one position */
{
ffmbyt(fptr, bytepos, REPORT_EOF, status);
ffgbyt(fptr, 80, inbuff, status); /* read the current keyword */
ffmbyt(fptr, bytepos, REPORT_EOF, status);
ffpbyt(fptr, 80, outbuff, status); /* overwrite with next keyword */
tmpbuff = inbuff; /* swap input and output buffers */
inbuff = outbuff;
outbuff = tmpbuff;
bytepos -= 80;
}
fptr->headend -= 80; /* decrement the position of the END keyword */
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclx( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG frow, /* I - first row to write (1 = 1st row) */
long fbit, /* I - first bit to write (1 = 1st) */
long nbit, /* I - number of bits to write */
char *larray, /* I - array of logicals corresponding to bits */
int *status) /* IO - error status */
/*
write an array of logical values to a specified bit or byte
column of the binary table. If larray is TRUE, then the corresponding
bit is set to 1, otherwise it is set to 0.
The binary table column being written to must have datatype 'B' or 'X'.
*/
{
LONGLONG offset, bstart, repeat, rowlen, elemnum, rstart, estart, tnull;
long fbyte, lbyte, nbyte, bitloc, ndone;
long ii, twidth, incre;
int tcode, descrp, maxelem, hdutype;
double dummyd;
char tform[12], snull[12];
unsigned char cbuff;
static unsigned char onbit[8] = {128, 64, 32, 16, 8, 4, 2, 1};
static unsigned char offbit[8] = {127, 191, 223, 239, 247, 251, 253, 254};
tcolumn *colptr;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* check input parameters */
if (nbit < 1)
return(*status);
else if (frow < 1)
return(*status = BAD_ROW_NUM);
else if (fbit < 1)
return(*status = BAD_ELEM_NUM);
/* reset position to the correct HDU if necessary */
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
/* rescan header if data structure is undefined */
else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
if ( ffrdef(fptr, status) > 0)
return(*status);
fbyte = (fbit + 7) / 8;
lbyte = (fbit + nbit + 6) / 8;
nbyte = lbyte - fbyte +1;
/* Save the current heapsize; ffgcprll will increment the value if */
/* we are writing to a variable length column. */
offset = (fptr->Fptr)->heapsize;
/* call ffgcprll in case we are writing beyond the current end of */
/* the table; it will allocate more space and shift any following */
/* HDU's. Otherwise, we have little use for most of the returned */
/* parameters, therefore just use dummy parameters. */
if (ffgcprll( fptr, colnum, frow, fbyte, nbyte, 1, &dummyd, &dummyd,
tform, &twidth, &tcode, &maxelem, &bstart, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
bitloc = fbit - 1 - ((fbit - 1) / 8 * 8);
ndone = 0;
rstart = frow - 1;
estart = fbyte - 1;
colptr = (fptr->Fptr)->tableptr; /* point to first column */
colptr += (colnum - 1); /* offset to correct column structure */
tcode = colptr->tdatatype;
if (abs(tcode) > TBYTE)
return(*status = NOT_LOGICAL_COL); /* not correct datatype column */
if (tcode > 0)
{
descrp = FALSE; /* not a variable length descriptor column */
repeat = colptr->trepeat;
if (tcode == TBIT)
repeat = (repeat + 7) / 8; /* convert from bits to bytes */
if (fbyte > repeat)
return(*status = BAD_ELEM_NUM);
/* calc the i/o pointer location to start of sequence of pixels */
bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
colptr->tbcol + estart;
}
else
{
descrp = TRUE; /* a variable length descriptor column */
/* only bit arrays (tform = 'X') are supported for variable */
/* length arrays. REPEAT is the number of BITS in the array. */
repeat = fbit + nbit -1;
/* write the number of elements and the starting offset. */
/* Note: ffgcprll previous wrote the descripter, but with the */
/* wrong repeat value (gave bytes instead of bits). */
if (tcode == -TBIT)
ffpdes(fptr, colnum, frow, (long) repeat, offset, status);
/* Calc the i/o pointer location to start of sequence of pixels. */
/* ffgcprll has already calculated a value for bstart that */
/* points to the first element of the vector; we just have to */
/* increment it to point to the first element we want to write to. */
/* Note: ffgcprll also already updated the size of the heap, so we */
/* don't have to do that again here. */
bstart += estart;
}
/* move the i/o pointer to the start of the pixel sequence */
ffmbyt(fptr, bstart, IGNORE_EOF, status);
/* read the next byte (we may only be modifying some of the bits) */
while (1)
{
if (ffgbyt(fptr, 1, &cbuff, status) == END_OF_FILE)
{
/* hit end of file trying to read the byte, so just set byte = 0 */
*status = 0;
cbuff = 0;
}
/* move back, to be able to overwrite the byte */
ffmbyt(fptr, bstart, IGNORE_EOF, status);
for (ii = bitloc; (ii < 8) && (ndone < nbit); ii++, ndone++)
{
if(larray[ndone])
cbuff = cbuff | onbit[ii];
else
cbuff = cbuff & offbit[ii];
}
ffpbyt(fptr, 1, &cbuff, status); /* write the modified byte */
if (ndone == nbit) /* finished all the bits */
return(*status);
/* not done, so get the next byte */
bstart++;
if (!descrp)
{
estart++;
if (estart == repeat)
{
/* move the i/o pointer to the next row of pixels */
estart = 0;
rstart = rstart + 1;
bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
colptr->tbcol;
ffmbyt(fptr, bstart, IGNORE_EOF, status);
}
}
bitloc = 0;
}
}
/*--------------------------------------------------------------------------*/
int ffpcll( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG firstrow, /* I - first row to write (1 = 1st row) */
LONGLONG firstelem, /* I - first vector element to write (1 = 1st) */
LONGLONG nelem, /* I - number of values to write */
char *array, /* I - array of values to write */
int *status) /* IO - error status */
/*
Write an array of logical values to a column in the current FITS HDU.
*/
{
int tcode, maxelem, hdutype;
long twidth, incre;
LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
double scale, zero;
char tform[20], ctrue = 'T', cfalse = 'F';
char message[FLEN_ERRMSG];
char snull[20]; /* the FITS null value */
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/*---------------------------------------------------*/
/* Check input and get parameters about the column: */
/*---------------------------------------------------*/
if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
if (tcode != TLOGICAL)
return(*status = NOT_LOGICAL_COL);
/*---------------------------------------------------------------------*/
/* Now write the logical values one at a time to the FITS column. */
/*---------------------------------------------------------------------*/
remain = nelem; /* remaining number of values to write */
next = 0; /* next element in array to be written */
rownum = 0; /* row number, relative to firstrow */
while (remain)
{
wrtptr = startpos + (rowlen * rownum) + (elemnum * incre);
ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */
if (array[next])
ffpbyt(fptr, 1, &ctrue, status);
else
ffpbyt(fptr, 1, &cfalse, status);
if (*status > 0) /* test for error during previous write operation */
{
sprintf(message,
"Error writing element %.0f of input array of logicals (ffpcll).",
(double) (next+1));
ffpmsg(message);
return(*status);
}
/*--------------------------------------------*/
/* increment the counters for the next loop */
/*--------------------------------------------*/
remain--;
if (remain)
{
next++;
elemnum++;
if (elemnum == repeat) /* completed a row; start on next row */
{
elemnum = 0;
rownum++;
}
}
} /* End of main while Loop */
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcld( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG firstrow, /* I - first row to write (1 = 1st row) */
LONGLONG firstelem, /* I - first vector element to write (1 = 1st) */
LONGLONG nelem, /* I - number of values to write */
double *array, /* I - array of values to write */
int *status) /* IO - error status */
/*
Write an array of values to a column in the current FITS HDU.
The column number may refer to a real column in an ASCII or binary table,
or it may refer to a virtual column in a 1 or more grouped FITS primary
array. FITSIO treats a primary array as a binary table
with 2 vector columns: the first column contains the group parameters (often
with length = 0) and the second column contains the array of image pixels.
Each row of the table represents a group in the case of multigroup FITS
images.
The input array of values will be converted to the datatype of the column
and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
int tcode, maxelem, hdutype, writeraw;
long twidth, incre;
long ntodo;
LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
double scale, zero;
char tform[20], cform[20];
char message[FLEN_ERRMSG];
char snull[20]; /* the FITS null value */
double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
void *buffer;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
buffer = cbuff;
/*---------------------------------------------------*/
/* Check input and get parameters about the column: */
/*---------------------------------------------------*/
if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
if (tcode == TSTRING)
ffcfmt(tform, cform); /* derive C format for writing strings */
/*
if there is no scaling and the native machine format is not byteswapped,
then we can simply write the raw data bytes into the FITS file if the
datatype of the FITS column is the same as the input values. Otherwise,
we must convert the raw values into the scaled and/or machine dependent
format in a temporary buffer that has been allocated for this purpose.
*/
if (scale == 1. && zero == 0. &&
MACHINE == NATIVE && tcode == TDOUBLE)
{
writeraw = 1;
maxelem = (int) nelem; /* we can write the entire array at one time */
}
else
writeraw = 0;
/*---------------------------------------------------------------------*/
/* Now write the pixels to the FITS column. */
/* First call the ffXXfYY routine to (1) convert the datatype */
/* if necessary, and (2) scale the values by the FITS TSCALn and */
/* TZEROn linear scaling parameters into a temporary buffer. */
/*---------------------------------------------------------------------*/
remain = nelem; /* remaining number of values to write */
next = 0; /* next element in array to be written */
rownum = 0; /* row number, relative to firstrow */
while (remain)
{
/* limit the number of pixels to process a one time to the number that
will fit in the buffer space or to the number of pixels that remain
in the current vector, which ever is smaller.
*/
ntodo = (long) minvalue(remain, maxelem);
ntodo = (long) minvalue(ntodo, (repeat - elemnum));
wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);
ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */
switch (tcode)
{
case (TDOUBLE):
if (writeraw)
{
/* write raw input bytes without conversion */
ffpr8b(fptr, ntodo, incre, &array[next], status);
}
else
{
/* convert the raw data before writing to FITS file */
ffr8fr8(&array[next], ntodo, scale, zero,
(double *) buffer, status);
ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
}
break;
case (TLONGLONG):
ffr8fi8(&array[next], ntodo, scale, zero,
(LONGLONG *) buffer, status);
ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
break;
case (TBYTE):
ffr8fi1(&array[next], ntodo, scale, zero,
(unsigned char *) buffer, status);
ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
break;
case (TSHORT):
ffr8fi2(&array[next], ntodo, scale, zero,
(short *) buffer, status);
ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
break;
case (TLONG):
ffr8fi4(&array[next], ntodo, scale, zero,
(INT32BIT *) buffer, status);
ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
break;
case (TFLOAT):
ffr8fr4(&array[next], ntodo, scale, zero,
(float *) buffer, status);
ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
break;
case (TSTRING): /* numerical column in an ASCII table */
if (cform[1] != 's') /* "%s" format is a string */
{
ffr8fstr(&array[next], ntodo, scale, zero, cform,
twidth, (char *) buffer, status);
if (incre == twidth) /* contiguous bytes */
ffpbyt(fptr, ntodo * twidth, buffer, status);
else
ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
status);
break;
}
/* can't write to string column, so fall thru to default: */
default: /* error trap */
sprintf(message,
"Cannot write numbers to column %d which has format %s",
colnum,tform);
ffpmsg(message);
if (hdutype == ASCII_TBL)
return(*status = BAD_ATABLE_FORMAT);
else
return(*status = BAD_BTABLE_FORMAT);
} /* End of switch block */
/*-------------------------*/
/* Check for fatal error */
/*-------------------------*/
if (*status > 0) /* test for error during previous write operation */
{
sprintf(message,
"Error writing elements %.0f thru %.0f of input data array (ffpcld).",
(double) (next+1), (double) (next+ntodo));
ffpmsg(message);
return(*status);
}
/*--------------------------------------------*/
/* increment the counters for the next loop */
/*--------------------------------------------*/
remain -= ntodo;
if (remain)
{
next += ntodo;
elemnum += ntodo;
if (elemnum == repeat) /* completed a row; start on next row */
{
elemnum = 0;
rownum++;
}
}
} /* End of main while Loop */
/*--------------------------------*/
/* check for numerical overflow */
/*--------------------------------*/
if (*status == OVERFLOW_ERR)
{
ffpmsg(
"Numerical overflow during type conversion while writing FITS data.");
*status = NUM_OVERFLOW;
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcls( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG firstrow, /* I - first row to write (1 = 1st row) */
LONGLONG firstelem, /* I - first vector element to write (1 = 1st) */
LONGLONG nelem, /* I - number of strings to write */
char **array, /* I - array of pointers to strings */
int *status) /* IO - error status */
/*
Write an array of string values to a column in the current FITS HDU.
*/
{
int tcode, maxelem, hdutype, nchar;
long twidth, incre;
long ii, jj, ntodo;
LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
double scale, zero;
char tform[20], *blanks;
char message[FLEN_ERRMSG];
char snull[20]; /* the FITS null value */
tcolumn *colptr;
double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
char *buffer, *arrayptr;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* reset position to the correct HDU if necessary */
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
{
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
}
else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
{
if ( ffrdef(fptr, status) > 0) /* rescan header */
return(*status);
}
/*---------------------------------------------------*/
/* Check input and get parameters about the column: */
/*---------------------------------------------------*/
if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
{
sprintf(message, "Specified column number is out of range: %d",
colnum);
ffpmsg(message);
return(*status = BAD_COL_NUM);
}
colptr = (fptr->Fptr)->tableptr; /* point to first column */
colptr += (colnum - 1); /* offset to correct column structure */
tcode = colptr->tdatatype;
if (tcode == -TSTRING) /* variable length column in a binary table? */
{
/* only write a single string; ignore value of firstelem */
nchar = maxvalue(1,strlen(array[0])); /* will write at least 1 char */
/* even if input string is null */
if (ffgcprll( fptr, colnum, firstrow, 1, nchar, 1, &scale, &zero,
tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
/* simply move to write position, then write the string */
ffmbyt(fptr, startpos, IGNORE_EOF, status);
ffpbyt(fptr, nchar, array[0], status);
if (*status > 0) /* test for error during previous write operation */
{
sprintf(message,
"Error writing to variable length string column (ffpcls).");
ffpmsg(message);
}
return(*status);
}
else if (tcode == TSTRING)
{
if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
/* if string length is greater than a FITS block (2880 char) then must */
/* only write 1 string at a time, to force writein by ffpbyt instead of */
/* ffpbytoff (ffpbytoff can't handle this case) */
if (twidth > IOBUFLEN) {
maxelem = 1;
incre = twidth;
repeat = 1;
}
blanks = (char *) malloc(twidth); /* string for blank fill values */
if (!blanks)
{
ffpmsg("Could not allocate memory for string (ffpcls)");
return(*status = ARRAY_TOO_BIG);
}
for (ii = 0; ii < twidth; ii++)
blanks[ii] = ' '; /* fill string with blanks */
remain = nelem; /* remaining number of values to write */
}
else
return(*status = NOT_ASCII_COL);
/*-------------------------------------------------------*/
/* Now write the strings to the FITS column. */
/*-------------------------------------------------------*/
next = 0; /* next element in array to be written */
rownum = 0; /* row number, relative to firstrow */
while (remain)
{
/* limit the number of pixels to process at one time to the number that
will fit in the buffer space or to the number of pixels that remain
in the current vector, which ever is smaller.
*/
ntodo = (long) minvalue(remain, maxelem);
ntodo = (long) minvalue(ntodo, (repeat - elemnum));
wrtptr = startpos + (rownum * rowlen) + (elemnum * incre);
ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */
buffer = (char *) cbuff;
/* copy the user's strings into the buffer */
for (ii = 0; ii < ntodo; ii++)
{
arrayptr = array[next];
for (jj = 0; jj < twidth; jj++) /* copy the string, char by char */
{
if (*arrayptr)
{
*buffer = *arrayptr;
buffer++;
arrayptr++;
}
else
break;
}
for (;jj < twidth; jj++) /* fill field with blanks, if needed */
{
*buffer = ' ';
buffer++;
}
next++;
}
/* write the buffer full of strings to the FITS file */
if (incre == twidth)
ffpbyt(fptr, ntodo * twidth, cbuff, status);
else
ffpbytoff(fptr, twidth, ntodo, incre - twidth, cbuff, status);
if (*status > 0) /* test for error during previous write operation */
{
sprintf(message,
"Error writing elements %.0f thru %.0f of input data array (ffpcls).",
(double) (next+1), (double) (next+ntodo));
ffpmsg(message);
if (blanks)
free(blanks);
return(*status);
}
/*--------------------------------------------*/
/* increment the counters for the next loop */
/*--------------------------------------------*/
remain -= ntodo;
if (remain)
{
elemnum += ntodo;
if (elemnum == repeat) /* completed a row; start on next row */
{
elemnum = 0;
rownum++;
}
}
} /* End of main while Loop */
if (blanks)
free(blanks);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclu( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG firstrow, /* I - first row to write (1 = 1st row) */
LONGLONG firstelem, /* I - first vector element to write (1 = 1st) */
LONGLONG nelempar, /* I - number of values to write */
int *status) /* IO - error status */
/*
Set elements of a table column to the appropriate null value for the column
The column number may refer to a real column in an ASCII or binary table,
or it may refer to a virtual column in a 1 or more grouped FITS primary
array. FITSIO treats a primary array as a binary table
with 2 vector columns: the first column contains the group parameters (often
with length = 0) and the second column contains the array of image pixels.
Each row of the table represents a group in the case of multigroup FITS
images.
This routine support COMPLEX and DOUBLE COMPLEX binary table columns, and
sets both the real and imaginary components of the element to a NaN.
*/
{
int tcode, maxelem, hdutype, writemode = 2, leng;
short i2null;
INT32BIT i4null;
long twidth, incre;
long ii;
LONGLONG largeelem, nelem, tnull, i8null;
LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, ntodo;
double scale, zero;
unsigned char i1null, lognul = 0;
char tform[20], *cstring = 0;
char message[FLEN_ERRMSG];
char snull[20]; /* the FITS null value */
long jbuff[2] = { -1, -1}; /* all bits set is equivalent to a NaN */
size_t buffsize;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
nelem = nelempar;
largeelem = firstelem;
/*---------------------------------------------------*/
/* Check input and get parameters about the column: */
/*---------------------------------------------------*/
/* note that writemode = 2 by default (not 1), so that the returned */
/* repeat and incre values will be the actual values for this column. */
/* If writing nulls to a variable length column then dummy data values */
/* must have already been written to the heap. */
/* We just have to overwrite the previous values with null values. */
/* Set writemode = 0 in this case, to test that values have been written */
fits_get_coltype(fptr, colnum, &tcode, NULL, NULL, status);
if (tcode < 0)
writemode = 0; /* this is a variable length column */
if (abs(tcode) >= TCOMPLEX)
{ /* treat complex columns as pairs of numbers */
largeelem = (largeelem - 1) * 2 + 1;
nelem *= 2;
}
if (ffgcprll( fptr, colnum, firstrow, largeelem, nelem, writemode, &scale,
&zero, tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
if (tcode == TSTRING)
{
if (snull[0] == ASCII_NULL_UNDEFINED)
{
ffpmsg(
"Null value string for ASCII table column is not defined (FTPCLU).");
return(*status = NO_NULL);
}
/* allocate buffer to hold the null string. Must write the entire */
/* width of the column (twidth bytes) to avoid possible problems */
/* with uninitialized FITS blocks, in case the field spans blocks */
buffsize = maxvalue(20, twidth);
cstring = (char *) malloc(buffsize);
if (!cstring)
return(*status = MEMORY_ALLOCATION);
memset(cstring, ' ', buffsize); /* initialize with blanks */
leng = strlen(snull);
if (hdutype == BINARY_TBL)
leng++; /* copy the terminator too in binary tables */
strncpy(cstring, snull, leng); /* copy null string to temp buffer */
}
else if ( tcode == TBYTE ||
tcode == TSHORT ||
tcode == TLONG ||
tcode == TLONGLONG)
{
if (tnull == NULL_UNDEFINED)
{
ffpmsg(
"Null value for integer table column is not defined (FTPCLU).");
return(*status = NO_NULL);
}
if (tcode == TBYTE)
i1null = (unsigned char) tnull;
else if (tcode == TSHORT)
{
i2null = (short) tnull;
#if BYTESWAPPED
ffswap2(&i2null, 1); /* reverse order of bytes */
#endif
}
else if (tcode == TLONG)
{
i4null = (INT32BIT) tnull;
#if BYTESWAPPED
ffswap4(&i4null, 1); /* reverse order of bytes */
#endif
}
else
{
i8null = tnull;
#if BYTESWAPPED
ffswap8((double *)(&i8null), 1); /* reverse order of bytes */
#endif
}
}
/*---------------------------------------------------------------------*/
/* Now write the pixels to the FITS column. */
/*---------------------------------------------------------------------*/
remain = nelem; /* remaining number of values to write */
next = 0; /* next element in array to be written */
rownum = 0; /* row number, relative to firstrow */
ntodo = remain; /* number of elements to write at one time */
while (ntodo)
{
/* limit the number of pixels to process at one time to the number that
will fit in the buffer space or to the number of pixels that remain
in the current vector, which ever is smaller.
*/
ntodo = minvalue(ntodo, (repeat - elemnum));
wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);
ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */
switch (tcode)
{
case (TBYTE):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 1, &i1null, status);
break;
case (TSHORT):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 2, &i2null, status);
break;
case (TLONG):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 4, &i4null, status);
break;
case (TLONGLONG):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 8, &i8null, status);
break;
case (TFLOAT):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 4, jbuff, status);
break;
case (TDOUBLE):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 8, jbuff, status);
break;
case (TLOGICAL):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 1, &lognul, status);
break;
case (TSTRING): /* an ASCII table column */
/* repeat always = 1, so ntodo is also guaranteed to = 1 */
ffpbyt(fptr, twidth, cstring, status);
break;
default: /* error trap */
sprintf(message,
"Cannot write null value to column %d which has format %s",
colnum,tform);
ffpmsg(message);
return(*status);
} /* End of switch block */
/*-------------------------*/
/* Check for fatal error */
/*-------------------------*/
if (*status > 0) /* test for error during previous write operation */
{
sprintf(message,
"Error writing %.0f thru %.0f of null values (ffpclu).",
(double) (next+1), (double) (next+ntodo));
ffpmsg(message);
if (cstring)
free(cstring);
return(*status);
}
/*--------------------------------------------*/
/* increment the counters for the next loop */
/*--------------------------------------------*/
remain -= ntodo;
if (remain)
{
next += ntodo;
elemnum += ntodo;
if (elemnum == repeat) /* completed a row; start on next row */
{
elemnum = 0;
rownum++;
}
}
ntodo = remain; /* this is the maximum number to do in next loop */
} /* End of main while Loop */
if (cstring)
free(cstring);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclu( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
long firstrow, /* I - first row to write (1 = 1st row) */
long firstelem, /* I - first vector element to write (1 = 1st) */
long nelem, /* I - number of values to write */
int *status) /* IO - error status */
/*
Set elements of a table column to the appropriate null value for the column
The column number may refer to a real column in an ASCII or binary table,
or it may refer to a virtual column in a 1 or more grouped FITS primary
array. FITSIO treats a primary array as a binary table
with 2 vector columns: the first column contains the group parameters (often
with length = 0) and the second column contains the array of image pixels.
Each row of the table represents a group in the case of multigroup FITS
images.
*/
{
int tcode, maxelem, hdutype, lennull, nwrite = 0, writemode = 2;
short i2null;
INT32BIT i4null;
long twidth, incre, rownum, remain, next, ntodo;
long tnull, ii;
OFF_T repeat, startpos, elemnum, large_elem, wrtptr, rowlen;
double scale, zero;
unsigned char i1null, lognul = 0;
char tform[20], cstring[50];
char message[FLEN_ERRMSG];
char snull[20]; /* the FITS null value */
long jbuff[2] = { -1, -1}; /* all bits set is equivalent to a NaN */
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if (firstelem == USE_LARGE_VALUE)
large_elem = large_first_elem_val;
else
large_elem = firstelem;
/*---------------------------------------------------*/
/* Check input and get parameters about the column: */
/*---------------------------------------------------*/
/* note that writemode = 2 by default (not 1), so that the returned */
/* repeat and incre values will be the actual values for this column. */
/* If writing nulls to a variable length column then dummy data values */
/* must have already been written to the heap. */
/* We just have to overwrite the previous values with null values. */
/* Set writemode = 0 in this case, to test that values have been written */
fits_get_coltype(fptr, colnum, &tcode, NULL, NULL, status);
if (tcode < 0)
writemode = 0; /* this is a variable length column */
if (ffgcpr( fptr, colnum, firstrow, large_elem, nelem, writemode, &scale,
&zero, tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
if (tcode == TSTRING)
{
if (snull[0] == ASCII_NULL_UNDEFINED)
{
ffpmsg(
"Null value string for ASCII table column is not defined (FTPCLU).");
return(*status = NO_NULL);
}
strcpy(cstring, snull); /* copy null string to temp buffer */
lennull = strlen(cstring);
if (hdutype == BINARY_TBL)
{ /* write up to and including null terminator into BINTABLE column */
nwrite = minvalue(twidth, lennull + 1);
}
else
{ /* write up to 20 chars to ASCII table column; pad with blanks */
nwrite = minvalue(twidth, 20);
for (ii = lennull; ii < nwrite; ii++)
cstring[ii] = ' ';
}
}
else if ( tcode == TBYTE ||
tcode == TSHORT ||
tcode == TLONG )
{
if (tnull == NULL_UNDEFINED)
{
ffpmsg(
"Null value for integer table column is not defined (FTPCLU).");
return(*status = NO_NULL);
}
if (tcode == TBYTE)
i1null = tnull;
else if (tcode == TSHORT)
{
i2null = tnull;
#if BYTESWAPPED
ffswap2(&i2null, 1); /* reverse order of bytes */
#endif
}
else
{
i4null = tnull;
#if BYTESWAPPED
ffswap4(&i4null, 1); /* reverse order of bytes */
#endif
}
}
/*---------------------------------------------------------------------*/
/* Now write the pixels to the FITS column. */
/*---------------------------------------------------------------------*/
remain = nelem; /* remaining number of values to write */
next = 0; /* next element in array to be written */
rownum = 0; /* row number, relative to firstrow */
ntodo = remain; /* number of elements to write at one time */
while (ntodo)
{
/* limit the number of pixels to process at one time to the number that
will fit in the buffer space or to the number of pixels that remain
in the current vector, which ever is smaller.
*/
ntodo = minvalue(ntodo, (repeat - elemnum));
wrtptr = startpos + ((OFF_T)rownum * rowlen) + (elemnum * incre);
ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */
switch (tcode)
{
case (TBYTE):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 1, &i1null, status);
break;
case (TSHORT):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 2, &i2null, status);
break;
case (TLONG):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 4, &i4null, status);
break;
case (TFLOAT):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 4, jbuff, status);
break;
case (TDOUBLE):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 8, jbuff, status);
break;
case (TLOGICAL):
for (ii = 0; ii < ntodo; ii++)
ffpbyt(fptr, 1, &lognul, status);
break;
case (TSTRING): /* an ASCII table column */
/* repeat always = 1, so ntodo is also guaranteed to = 1 */
ffpbyt(fptr, nwrite, cstring, status);
break;
default: /* error trap */
sprintf(message,
"Cannot write null value to column %d which has format %s",
colnum,tform);
ffpmsg(message);
return(*status);
} /* End of switch block */
/*-------------------------*/
/* Check for fatal error */
/*-------------------------*/
if (*status > 0) /* test for error during previous write operation */
{
sprintf(message,
"Error writing %ld thru %ld of null values (ffpclu).",
next+1, next+ntodo);
ffpmsg(message);
return(*status);
}
/*--------------------------------------------*/
/* increment the counters for the next loop */
/*--------------------------------------------*/
remain -= ntodo;
if (remain)
{
next += ntodo;
elemnum += ntodo;
if (elemnum == repeat) /* completed a row; start on next row */
{
elemnum = 0;
rownum++;
}
}
ntodo = remain; /* this is the maximum number to do in next loop */
} /* End of main while Loop */
return(*status);
}
