/*--------------------------------------------------------------------------*/
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);
}