/*--------------------------------------------------------------------------*/
int ffpgpj( fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long firstelem, /* I - first vector element to write(1 = 1st) */
long nelem, /* I - number of values to write */
long *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of group parameters to the primary array. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being written).
*/
{
long row;
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
row=maxvalue(1,group);
ffpclj(fptr, 1L, row, firstelem, nelem, array, status);
return(*status);
}
void FSPCLJ_U (fitsfile **fptr, int *colnum,
int *frow, int *felem, int *nelem,
int array[], int *status) {
long *larray;
int i;
larray = calloc (*nelem, sizeof(long));
for (i = 0; i < *nelem; i++)
larray[i] = array[i];
ffpclj (*fptr, *colnum,
(long)*frow, (long)*felem, (long)*nelem,
larray, status);
free (larray);
}
/*--------------------------------------------------------------------------*/
int ffpclk( 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 */
int *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, maxelem2, hdutype, writeraw;
long twidth, incre;
long ntodo;
LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
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);
/* call the 'short' or 'long' version of this routine, if possible */
if (sizeof(int) == sizeof(short))
ffpcli(fptr, colnum, firstrow, firstelem, nelem,
(short *) array, status);
else if (sizeof(int) == sizeof(long))
ffpclj(fptr, colnum, firstrow, firstelem, nelem,
(long *) array, status);
else
{
/*
This is a special case: sizeof(int) is not equal to sizeof(short) or
sizeof(long). This occurs on Alpha OSF systems where short = 2 bytes,
int = 4 bytes, and long = 8 bytes.
*/
buffer = cbuff;
/*---------------------------------------------------*/
/* Check input and get parameters about the column: */
/*---------------------------------------------------*/
if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
maxelem = maxelem2;
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 == TLONG)
{
writeraw = 1;
if (nelem < (LONGLONG)INT32_MAX) {
maxelem = nelem;
} else {
maxelem = INT32_MAX/4;
}
}
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 (TLONG):
if (writeraw)
{
/* write raw input bytes without conversion */
ffpi4b(fptr, ntodo, incre, (INT32BIT *) &array[next], status);
}
else
{
/* convert the raw data before writing to FITS file */
ffintfi4(&array[next], ntodo, scale, zero,
(INT32BIT *) buffer, status);
ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
}
break;
case (TLONGLONG):
ffintfi8(&array[next], ntodo, scale, zero,
(LONGLONG *) buffer, status);
ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
break;
case (TBYTE):
ffintfi1(&array[next], ntodo, scale, zero,
(unsigned char *) buffer, status);
ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
break;
case (TSHORT):
ffintfi2(&array[next], ntodo, scale, zero,
(short *) buffer, status);
ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
break;
case (TFLOAT):
ffintfr4(&array[next], ntodo, scale, zero,
(float *) buffer, status);
ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
break;
case (TDOUBLE):
ffintfr8(&array[next], ntodo, scale, zero,
(double *) buffer, status);
ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
break;
case (TSTRING): /* numerical column in an ASCII table */
if (cform[1] != 's') /* "%s" format is a string */
{
ffintfstr(&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 */
snprintf(message, FLEN_ERRMSG,
"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 */
{
snprintf(message,FLEN_ERRMSG,
"Error writing elements %.0f thru %.0f of input data array (ffpclk).",
(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;
}
} /* end of Dec ALPHA special case */
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcl( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
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 elements to write */
void *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of values to a table column. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS column is not the same as the array being written).
*/
{
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if (datatype == TBIT)
{
ffpclx(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
status);
}
else if (datatype == TBYTE)
{
ffpclb(fptr, colnum, firstrow, firstelem, nelem, (unsigned char *) array,
status);
}
else if (datatype == TUSHORT)
{
ffpclui(fptr, colnum, firstrow, firstelem, nelem,
(unsigned short *) array, status);
}
else if (datatype == TSHORT)
{
ffpcli(fptr, colnum, firstrow, firstelem, nelem, (short *) array,
status);
}
else if (datatype == TUINT)
{
ffpcluk(fptr, colnum, firstrow, firstelem, nelem, (unsigned int *) array,
status);
}
else if (datatype == TINT)
{
ffpclk(fptr, colnum, firstrow, firstelem, nelem, (int *) array,
status);
}
else if (datatype == TULONG)
{
ffpcluj(fptr, colnum, firstrow, firstelem, nelem, (unsigned long *) array,
status);
}
else if (datatype == TLONG)
{
ffpclj(fptr, colnum, firstrow, firstelem, nelem, (long *) array,
status);
}
else if (datatype == TFLOAT)
{
ffpcle(fptr, colnum, firstrow, firstelem, nelem, (float *) array,
status);
}
else if (datatype == TDOUBLE)
{
ffpcld(fptr, colnum, firstrow, firstelem, nelem, (double *) array,
status);
}
else if (datatype == TCOMPLEX)
{
ffpcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
(float *) array, status);
}
else if (datatype == TDBLCOMPLEX)
{
ffpcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
(double *) array, status);
}
else if (datatype == TLOGICAL)
{
ffpcll(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
status);
}
else if (datatype == TSTRING)
{
ffpcls(fptr, colnum, firstrow, firstelem, nelem, (char **) array,
status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppr( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long firstelem, /* I - first vector element to write(1 = 1st) */
long nelem, /* I - number of values to write */
void *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of values to the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being written).
*/
{
long row = 1;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (datatype == TBYTE)
{
ffpclb(fptr, 2, row, firstelem, nelem, (unsigned char *) array, status);
}
else if (datatype == TUSHORT)
{
ffpclui(fptr, 2, row, firstelem, nelem, (unsigned short *) array,
status);
}
else if (datatype == TSHORT)
{
ffpcli(fptr, 2, row, firstelem, nelem, (short *) array, status);
}
else if (datatype == TUINT)
{
ffpcluk(fptr, 2, row, firstelem, nelem, (unsigned int *) array, status);
}
else if (datatype == TINT)
{
ffpclk(fptr, 2, row, firstelem, nelem, (int *) array, status);
}
else if (datatype == TULONG)
{
ffpcluj(fptr, 2, row, firstelem, nelem, (unsigned long *) array, status);
}
else if (datatype == TLONG)
{
ffpclj(fptr, 2, row, firstelem, nelem, (long *) array, status);
}
else if (datatype == TFLOAT)
{
ffpcle(fptr, 2, row, firstelem, nelem, (float *) array, status);
}
else if (datatype == TDOUBLE)
{
ffpcld(fptr, 2, row, firstelem, nelem, (double *) array, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppx( fitsfile *fptr, /* I - FITS file pointer */
int datatype, /* I - datatype of the value */
long *firstpix, /* I - coord of first pixel to write(1 based) */
long nelem, /* I - number of values to write */
void *array, /* I - array of values that are written */
int *status) /* IO - error status */
/*
Write an array of pixels to the primary array. The datatype of the
input array is defined by the 2nd argument. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of
the FITS array is not the same as the array being written). This routine
is simillar to ffppr, except it supports writing large images with
more than 2.1E9 pixels.
*/
{
int naxis, ii;
long naxes[9], firstelem, row = 1;
OFF_T dimsize = 1;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* get the size of the image */
ffgidm(fptr, &naxis, status);
ffgisz(fptr, 9, naxes, status);
/* store the actual first element value in a external variable */
/* because we can't pass the value directly to the lower routine */
/* because the parameter is declared as 'long' instead of 'off_t'. */
large_first_elem_val = 0;
for (ii=0; ii < naxis; ii++)
{
large_first_elem_val += ((firstpix[ii] - 1) * dimsize);
dimsize *= naxes[ii];
}
large_first_elem_val++;
firstelem = USE_LARGE_VALUE; /* special flag value */
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (datatype == TBYTE)
{
ffpclb(fptr, 2, row, firstelem, nelem, (unsigned char *) array, status);
}
else if (datatype == TUSHORT)
{
ffpclui(fptr, 2, row, firstelem, nelem, (unsigned short *) array,
status);
}
else if (datatype == TSHORT)
{
ffpcli(fptr, 2, row, firstelem, nelem, (short *) array, status);
}
else if (datatype == TUINT)
{
ffpcluk(fptr, 2, row, firstelem, nelem, (unsigned int *) array, status);
}
else if (datatype == TINT)
{
ffpclk(fptr, 2, row, firstelem, nelem, (int *) array, status);
}
else if (datatype == TULONG)
{
ffpcluj(fptr, 2, row, firstelem, nelem, (unsigned long *) array, status);
}
else if (datatype == TLONG)
{
ffpclj(fptr, 2, row, firstelem, nelem, (long *) array, status);
}
else if (datatype == TFLOAT)
{
ffpcle(fptr, 2, row, firstelem, nelem, (float *) array, status);
}
else if (datatype == TDOUBLE)
{
ffpcld(fptr, 2, row, firstelem, nelem, (double *) array, status);
}
else
*status = BAD_DATATYPE;
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnj( 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 */
long *array, /* I - array of values to write */
long nulvalue, /* I - value used to flag undefined pixels */
int *status) /* IO - error status */
/*
Write an array of elements to the specified column of a table. Any input
pixels equal to the value of nulvalue will be replaced by the appropriate
null value in the output FITS file.
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
*/
{
tcolumn *colptr;
long ngood = 0, nbad = 0, ii, fstrow;
OFF_T large_elem, repeat, first, fstelm;
if (*status > 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);
}
colptr = (fptr->Fptr)->tableptr; /* point to first column */
colptr += (colnum - 1); /* offset to correct column structure */
repeat = colptr->trepeat; /* repeat count for this column */
if (firstelem == USE_LARGE_VALUE)
large_elem = large_first_elem_val;
else
large_elem = firstelem;
/* hereafter, pass first element parameter via global variable */
firstelem = USE_LARGE_VALUE;
/* absolute element number in the column */
first = (firstrow - 1) * repeat + large_elem;
for (ii = 0; ii < nelem; ii++)
{
if (array[ii] != nulvalue) /* is this a good pixel? */
{
if (nbad) /* write previous string of bad pixels */
{
fstelm = ii - nbad + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
if (ffpclu(fptr, colnum, fstrow, firstelem, nbad, status) > 0)
return(*status);
nbad=0;
}
ngood = ngood +1; /* the consecutive number of good pixels */
}
else
{
if (ngood) /* write previous string of good pixels */
{
fstelm = ii - ngood + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
if (ffpclj(fptr, colnum, fstrow, firstelem, ngood, &array[ii-ngood],
status) > 0)
return(*status);
ngood=0;
}
nbad = nbad +1; /* the consecutive number of bad pixels */
}
}
/* finished loop; now just write the last set of pixels */
if (ngood) /* write last string of good pixels */
{
fstelm = ii - ngood + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
ffpclj(fptr, colnum, fstrow, firstelem, ngood, &array[ii-ngood], status);
}
else /* write last string of bad pixels */
{
fstelm = ii - nbad + first; /* absolute element number */
fstrow = (fstelm - 1) / repeat + 1; /* starting row number */
fstelm = fstelm - (fstrow - 1) * repeat; /* relative number */
large_first_elem_val = fstelm;
ffpclu(fptr, colnum, fstrow, firstelem, nbad, status);
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssj(fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long naxis, /* I - number of data axes in array */
long *naxes, /* I - size of each FITS axis */
long *fpixel, /* I - 1st pixel in each axis to write (1=1st) */
long *lpixel, /* I - last pixel in each axis to write */
long *array, /* I - array to be written */
int *status) /* IO - error status */
/*
Write a subsection of pixels to the primary array or image.
A subsection is defined to be any contiguous rectangular
array of pixels within the n-dimensional FITS data file.
Data conversion and scaling will be performed if necessary
(e.g, if the datatype of the FITS array is not the same as
the array being written).
*/
{
long tablerow;
long fpix[7], irange[7], dimen[7], astart, pstart;
long off2, off3, off4, off5, off6, off7;
long st10, st20, st30, st40, st50, st60, st70;
long st1, st2, st3, st4, st5, st6, st7;
long ii, i1, i2, i3, i4, i5, i6, i7;
if (*status > 0)
return(*status);
if (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
ffpmsg("writing to compressed image is not supported");
return(*status = DATA_COMPRESSION_ERR);
}
if (naxis < 1 || naxis > 7)
return(*status = BAD_DIMEN);
tablerow=maxvalue(1,group);
/* calculate the size and number of loops to perform in each dimension */
for (ii = 0; ii < 7; ii++)
{
fpix[ii]=1;
irange[ii]=1;
dimen[ii]=1;
}
for (ii = 0; ii < naxis; ii++)
{
fpix[ii]=fpixel[ii];
irange[ii]=lpixel[ii]-fpixel[ii]+1;
dimen[ii]=naxes[ii];
}
i1=irange[0];
/* compute the pixel offset between each dimension */
off2 = dimen[0];
off3 = off2 * dimen[1];
off4 = off3 * dimen[2];
off5 = off4 * dimen[3];
off6 = off5 * dimen[4];
off7 = off6 * dimen[5];
st10 = fpix[0];
st20 = (fpix[1] - 1) * off2;
st30 = (fpix[2] - 1) * off3;
st40 = (fpix[3] - 1) * off4;
st50 = (fpix[4] - 1) * off5;
st60 = (fpix[5] - 1) * off6;
st70 = (fpix[6] - 1) * off7;
/* store the initial offset in each dimension */
st1 = st10;
st2 = st20;
st3 = st30;
st4 = st40;
st5 = st50;
st6 = st60;
st7 = st70;
astart = 0;
for (i7 = 0; i7 < irange[6]; i7++)
{
for (i6 = 0; i6 < irange[5]; i6++)
{
for (i5 = 0; i5 < irange[4]; i5++)
{
for (i4 = 0; i4 < irange[3]; i4++)
{
for (i3 = 0; i3 < irange[2]; i3++)
{
pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;
for (i2 = 0; i2 < irange[1]; i2++)
{
if (ffpclj(fptr, 2, tablerow, pstart, i1, &array[astart],
status) > 0)
return(*status);
astart += i1;
pstart += off2;
}
st2 = st20;
st3 = st3+off3;
}
st3 = st30;
st4 = st4+off4;
}
st4 = st40;
st5 = st5+off5;
}
st5 = st50;
st6 = st6+off6;
}
st6 = st60;
st7 = st7+off7;
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dj(fitsfile *fptr, /* I - FITS file pointer */
long group, /* I - group to write(1 = 1st group) */
long ncols, /* I - number of pixels in each row of array */
long nrows, /* I - number of rows in each plane of array */
long naxis1, /* I - FITS image NAXIS1 value */
long naxis2, /* I - FITS image NAXIS2 value */
long naxis3, /* I - FITS image NAXIS3 value */
long *array, /* I - array to be written */
int *status) /* IO - error status */
/*
Write an entire 3-D cube of values to the primary array. Data conversion
and scaling will be performed if necessary (e.g, if the datatype of the
FITS array is not the same as the array being written).
*/
{
long tablerow, nfits, narray, ii, jj;
/*
the primary array is represented as a binary table:
each group of the primary array is a row in the table,
where the first column contains the group parameters
and the second column contains the image itself.
*/
if (fits_is_compressed_image(fptr, status))
{
/* this is a compressed image in a binary table */
ffpmsg("writing to compressed image is not supported");
return(*status = DATA_COMPRESSION_ERR);
}
tablerow=maxvalue(1,group);
if (ncols == naxis1 && nrows == naxis2) /* arrays have same size? */
{
/* all the image pixels are contiguous, so write all at once */
ffpclj(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
return(*status);
}
if (ncols < naxis1 || nrows < naxis2)
return(*status = BAD_DIMEN);
nfits = 1; /* next pixel in FITS image to write to */
narray = 0; /* next pixel in input array to be written */
/* loop over naxis3 planes in the data cube */
for (jj = 0; jj < naxis3; jj++)
{
/* loop over the naxis2 rows in the FITS image, */
/* writing naxis1 pixels to each row */
for (ii = 0; ii < naxis2; ii++)
{
if (ffpclj(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
return(*status);
nfits += naxis1;
narray += ncols;
}
narray += (nrows - naxis2) * ncols;
}
return(*status);
}
