int main(int argc, char *argv[])
{
fitsfile *infptr = 0, *outfptr = 0; /* FITS file pointers */
int status = 0; /* CFITSIO status value MUST be initialized to zero! */
int hdutype = 0, hdunum = 0, ii = 0;
int printhelp = (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0));
if (printhelp || argc != 4) {
fprintf(stderr, "Usage: %s infile expression outfile\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "Copy selected rows from the input table to the output file\n");
fprintf(stderr, "based on the input boolean expression. The expression may \n");
fprintf(stderr, "be a function of the values in other table columns or header \n");
fprintf(stderr, "keyword values. If the expression evaluates to 'true' then \n");
fprintf(stderr, "that row is copied to the output file.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Example: \n");
fprintf(stderr, "1. %s intab.fits+1 'counts > 0' outab.fits\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, " copy rows that have a positive 'counts' column value\n");
fprintf(stderr, "\n");
fprintf(stderr, "2. %s intab.fits+1 'gtifilter()' outab.fits\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, " Select rows which have a Time column value that is\n");
fprintf(stderr, " within one of the Good Time Intervals (GTI) which are\n");
fprintf(stderr, " defined in a separate GTI extension in the same file.\n");
fprintf(stderr, "\n");
fprintf(stderr, "3. %s intab.fits+1 'regfilter(\"pow.reg\")' outab.fits\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, " Select rows which have X,Y column coordinates located\n");
fprintf(stderr, " within the spatial region defined in the file named\n");
fprintf(stderr, " 'pow.reg'. This is an ASCII text file containing a\n");
fprintf(stderr, " list of one or more geometric regions such as circle,\n");
fprintf(stderr, " rectangle, annulus, etc.\n");
return (0);
}
if (!fits_open_file(&infptr, argv[1], READONLY, &status)) {
if (fits_get_hdu_type(infptr, &hdutype,&status) ||
hdutype==IMAGE_HDU) {
fprintf(stderr, "Error: input HDU is not a table\n");
} else {
fits_get_hdu_num(infptr, &hdunum); /* save current HDU location */
if (!fits_create_file(&outfptr, argv[3], &status)) {
/* copy all the HDUs from the input file to the output file */
for (ii = 1; !status; ii++) {
if (!fits_movabs_hdu(infptr, ii, NULL, &status)) {
fits_copy_hdu(infptr, outfptr, 0, &status);
}
}
if (status == END_OF_FILE) {
status = 0; /* reset expected error */
}
/* move back to initial position in the file */
fits_movabs_hdu(outfptr, hdunum, NULL, &status);
/* argv[2] is the expression */
/* input and output files are the same, so delete rows that */
/* do not satisfy the expression */
fits_select_rows(outfptr, outfptr, argv[2], &status);
fits_close_file(outfptr, &status); /* Done */
}
}
fits_close_file(infptr, &status);
}
if (status) {
fits_report_error(stderr, status); /* print any error message */
}
return (status);
}
int main(int argc, char *argv[])
{
fitsfile *infptr = 0, *outfptr = 0; /* FITS file pointers */
int status = 0; /* CFITSIO status value MUST be initialized to zero! */
int icol = 0, incols = 0, outcols = 0, intype = 0, outtype = 0, check = 1;
long inrep = 0, outrep = 0, width = 0, inrows = 0, outrows = 0, ii = 0, jj = 0;
unsigned char *buffer = 0;
int printhelp = (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0));
if (printhelp || argc != 3) {
fprintf(stderr, "Usage: %s infile1[ext][filter] outfile[ext]\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "Merge 2 tables by copying all the rows from the 1st table\n");
fprintf(stderr, "into the 2nd table. The 2 tables must have identical\n");
fprintf(stderr, "structure, with the same number of columns with the same\n");
fprintf(stderr, "datatypes. This program modifies the output file in place,\n");
fprintf(stderr, "rather than creating a whole new output file.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Examples: \n");
fprintf(stderr, "\n");
fprintf(stderr, "1. %s intab.fit+1 outtab.fit+2\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, " merge the table in the 1st extension of intab.fit with\n");
fprintf(stderr, " the table in the 2nd extension of outtab.fit.\n");
fprintf(stderr, "\n");
fprintf(stderr, "2. %s 'intab.fit+1[PI > 45]' outab.fits+2\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, " Same as the 1st example, except only rows that have a PI\n");
fprintf(stderr, " column value > 45 will be merged into the output table.\n");
fprintf(stderr, "\n");
return (0);
}
/* open both input and output files and perform validity checks */
if (fits_open_file(&infptr, argv[1], READONLY, &status) ||
fits_open_file(&outfptr, argv[2], READWRITE, &status)) {
fprintf(stderr, " Couldn't open both files\n");
}
else if (fits_get_hdu_type(infptr, &intype, &status) ||
fits_get_hdu_type(outfptr, &outtype, &status)) {
fprintf(stderr, "couldn't get the type of HDU for the files\n");
}
else if (intype == IMAGE_HDU) {
fprintf(stderr, "The input HDU is an image, not a table\n");
}
else if (outtype == IMAGE_HDU) {
fprintf(stderr, "The output HDU is an image, not a table\n");
}
else if (outtype != intype) {
fprintf(stderr, "Input and output HDUs are not the same type of table.\n");
}
else if (fits_get_num_cols(infptr, &incols, &status) ||
fits_get_num_cols(outfptr, &outcols, &status)) {
fprintf(stderr, "Couldn't get number of columns in the tables\n");
}
else if (incols != outcols) {
fprintf(stderr, "Input and output HDUs don't have same # of columns.\n");
}
else if (fits_read_key(infptr, TLONG, "NAXIS1", &width, NULL, &status)) {
fprintf(stderr, "Couldn't get width of input table\n");
}
else if (!(buffer = (unsigned char *) malloc(width))) {
fprintf(stderr, "memory allocation error\n");
}
else if (fits_get_num_rows(infptr, &inrows, &status) ||
fits_get_num_rows(outfptr, &outrows, &status)) {
fprintf(stderr, "Couldn't get the number of rows in the tables\n");
}
else {
/* check that the corresponding columns have the same datatypes */
for (icol = 1; icol <= incols; icol++) {
fits_get_coltype(infptr, icol, &intype, &inrep, NULL, &status);
fits_get_coltype(outfptr, icol, &outtype, &outrep, NULL, &status);
if (intype != outtype || inrep != outrep) {
fprintf(stderr, "Column %d is not the same in both tables\n", icol);
check = 0;
}
}
if (check && !status) {
/* insert 'inrows' empty rows at the end of the output table */
fits_insert_rows(outfptr, outrows, inrows, &status);
for (ii = 1, jj = outrows +1; ii <= inrows; ii++, jj++) {
/* read row from input and write it to the output table */
fits_read_tblbytes(infptr, ii, 1, width, buffer, &status);
fits_write_tblbytes(outfptr, jj, 1, width, buffer, &status);
if (status) {
break; /* jump out of loop if error occurred */
}
}
/* all done; now free memory and close files */
fits_close_file(outfptr, &status);
fits_close_file(infptr, &status);
}
}
if (buffer) {
free(buffer);
}
if (status) {
fits_report_error(stderr, status); /* print any error message */
}
return (status);
}
int HEALPixIn(struct healpix *hpxdat)
{
char crdsys[32], ordering[32];
int anynul, hdutype, iaxis, nfound, status;
long firstpix, ipix, lastpix, naxis, *naxes = 0x0, nside = 0, repeat;
float *datap, nulval;
LONGLONG firstelem, irow, nelem, npix = 0, nrow = 0;
fitsfile *fptr;
status = 0;
hpxdat->data = 0x0;
/* Open the FITS file and move to the first HDU with NAXIS != 0. */
if (fits_open_data(&fptr, hpxdat->infile, READONLY, &status)) goto fitserr;
/* Is this the primary HDU or an extension? */
if (fits_get_hdu_type(fptr, &hdutype, &status)) goto fitserr;
if (!(hdutype == IMAGE_HDU || hdutype == BINARY_TBL)) {
fprintf(stderr, "ERROR: %s does not contain HEALPix data.\n",
hpxdat->infile);
return 1;
}
/* Get the image size. */
if (fits_read_key_lng(fptr, "NAXIS", &naxis, 0x0, &status)) goto fitserr;
naxes = malloc(naxis*sizeof(long));
if (fits_read_keys_lng(fptr, "NAXIS", 1, (int)naxis, naxes, &nfound,
&status)) goto fitserr;
if (hdutype == IMAGE_HDU) {
/* Look for the first non-degenerate image axis. */
for (iaxis = 0; iaxis < nfound; iaxis++) {
if (naxes[iaxis] > 1) {
/* Assume for now that it is the total number of pixels. */
npix = naxes[iaxis];
break;
}
}
} else if (hdutype == BINARY_TBL) {
/* Binary tables are simpler. */
if (nfound > 1) nrow = naxes[1];
/* (Note that fits_get_coltypell() is not available in cfitsio 2.x.) */
if (fits_get_coltype(fptr, hpxdat->col, 0x0, &repeat, 0x0, &status)) {
goto fitserr;
}
nelem = (LONGLONG)repeat;
}
if (!npix && !nrow) {
fprintf(stderr, "ERROR: Could not determine image size.\n");
goto cleanup;
}
/* Number of pixels per side of each base-resolution pixel. */
if (fits_read_key_lng(fptr, "NSIDE", &nside, 0x0, &status)) {
/* Some HEALPix files, e.g. SFD dust maps, don't record NSIDE. */
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
}
/* FIRSTPIX and LASTPIX, if present, record the 0-relative pixel numbers of
* the first and last pixels stored in the data. */
firstpix = -1;
if (fits_read_key_lng(fptr, "FIRSTPIX", &firstpix, 0x0, &status)) {
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
}
lastpix = -1;
if (fits_read_key_lng(fptr, "LASTPIX", &lastpix, 0x0, &status)) {
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
}
if (!nside) {
/* Deduce NSIDE. */
if (lastpix >= 0) {
/* If LASTPIX is present without NSIDE we can only assume it's npix. */
nside = (int)(sqrt((double)((lastpix+1) / 12)) + 0.5);
} else if (npix) {
nside = (int)(sqrt((double)(npix / 12)) + 0.5);
} else if (nrow) {
nside = (int)(sqrt((double)((nrow * nelem) / 12)) + 0.5);
}
}
hpxdat->nside = (int)nside;
hpxdat->npix = 12*nside*nside;
/* Ensure that FIRSTPIX and LASTPIX are set. */
if (firstpix < 0) firstpix = 0;
if (lastpix < 0) lastpix = hpxdat->npix - 1;
/* Any sign of a coordinate system identifier? */
if (fits_read_key_str(fptr, "COORDSYS", crdsys, 0x0, &status)) {
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
} else if (crdsys[0] == 'G') {
hpxdat->crdsys = 'G';
} else if (crdsys[0] == 'E') {
hpxdat->crdsys = 'E';
} else if (crdsys[0] == 'C') {
/* ("celestial") */
hpxdat->crdsys = 'Q';
}
/* Nested or ring ordering? */
if (fits_read_key_str(fptr, "ORDERING", ordering, 0x0, &status)) {
/* Some HEALPix files, e.g. SFD dust maps, don't record ORDERING. */
if (status != KEY_NO_EXIST) goto fitserr;
status = 0;
} else if (strcmp(ordering, "NESTED") == 0) {
hpxdat->ordering = 'N';
} else if (strcmp(ordering, "RING") == 0) {
hpxdat->ordering = 'R';
} else {
fprintf(stderr, "WARNING: Invalid ORDERING keyword: %s.\n", ordering);
}
/* Allocate memory and read the data. */
if ((hpxdat->data = malloc((hpxdat->npix)*sizeof(float))) == NULL) {
perror("HPXcvt");
goto cleanup;
}
nulval = HEALPIX_NULLVAL;
datap = hpxdat->data;
for (ipix = 0; ipix < firstpix; ipix++) {
*(datap++) = nulval;
}
firstelem = (LONGLONG)1;
if (hdutype == IMAGE_HDU) {
if (fits_read_img_flt(fptr, 0l, firstelem, npix, nulval, datap, &anynul,
&status)) goto fitserr;
} else if (hdutype == BINARY_TBL) {
for (irow = 0; irow < nrow; irow++) {
if (fits_read_col_flt(fptr, hpxdat->col, irow+1, firstelem, nelem,
nulval, datap, &anynul, &status)) goto fitserr;
datap += nelem;
}
}
datap = hpxdat->data + (lastpix + 1);
for (ipix = (lastpix+1); ipix < hpxdat->npix; ipix++) {
*(datap++) = nulval;
}
/* Clean up. */
fits_close_file(fptr, &status);
status = 0;
return 0;
fitserr:
fits_report_error(stderr, status);
cleanup:
if (naxes) free(naxes);
if (hpxdat->data) free(hpxdat->data);
hpxdat->data = 0x0;
return 1;
}
int main(int argc, char *argv[])
{
fitsfile *infptr, *outfptr; /* FITS file pointers defined in fitsio.h */
int status = 0, ii = 1, iteration = 0, single = 0, hdupos;
int hdutype, bitpix, bytepix, naxis = 0, nkeys, datatype = 0, anynul;
long naxes[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
long first, totpix = 0, npix;
double *array, bscale = 1.0, bzero = 0.0, nulval = 0.;
char card[81];
if (argc != 3)
{
printf("\n");
printf("Usage: imcopy inputImage outputImage[compress]\n");
printf("\n");
printf("Copy an input image to an output image, optionally compressing\n");
printf("or uncompressing the image in the process. If the [compress]\n");
printf("qualifier is appended to the output file name then the input image\n");
printf("will be compressed using the tile-compressed format. In this format,\n");
printf("the image is divided into rectangular tiles and each tile of pixels\n");
printf("is compressed and stored in a variable-length row of a binary table.\n");
printf("If the [compress] qualifier is omitted, and the input image is\n");
printf("in tile-compressed format, then the output image will be uncompressed.\n");
printf("\n");
printf("If an extension name or number is appended to the input file name, \n");
printf("enclosed in square brackets, then only that single extension will be\n");
printf("copied to the output file. Otherwise, every extension in the input file\n");
printf("will be processed in turn and copied to the output file.\n");
printf("\n");
printf("Examples:\n");
printf("\n");
printf("1) imcopy image.fit 'cimage.fit[compress]'\n");
printf("\n");
printf(" This compresses the input image using the default parameters, i.e.,\n");
printf(" using the Rice compression algorithm and using row by row tiles.\n");
printf("\n");
printf("2) imcopy cimage.fit image2.fit\n");
printf("\n");
printf(" This uncompress the image created in the first example.\n");
printf(" image2.fit should be identical to image.fit if the image\n");
printf(" has an integer datatype. There will be small differences\n");
printf(" in the pixel values if it is a floating point image.\n");
printf("\n");
printf("3) imcopy image.fit 'cimage.fit[compress GZIP 100,100;4]'\n");
printf("\n");
printf(" This compresses the input image using the following parameters:\n");
printf(" GZIP compression algorithm;\n");
printf(" 100 X 100 pixel compression tiles;\n");
printf(" noise_bits = 4 (only used with floating point images)\n");
printf("\n");
printf("The full syntax of the compression qualifier is:\n");
printf(" [compress ALGORITHM TDIM1,TDIM2,...; NOISE_BITS]\n");
printf("where the allowed ALGORITHM values are Rice, GZIP, PLIO, \n");
printf("and TDIMn is the size of the compression tile in each dimension,\n");
printf("and NOISE_BITS = 1, 2, 3, or 4 and controls the amount of noise\n");
printf("suppression when compressing floating point images. \n");
printf("\n");
printf("Note that it may be necessary to enclose the file names\n");
printf("in single quote characters on the Unix command line.\n");
return(0);
}
/* Open the input file and create output file */
fits_open_file(&infptr, argv[1], READONLY, &status);
fits_create_file(&outfptr, argv[2], &status);
if (status != 0) {
fits_report_error(stderr, status);
return(status);
}
fits_get_hdu_num(infptr, &hdupos); /* Get the current HDU position */
/* Copy only a single HDU if a specific extension was given */
if (hdupos != 1 || strchr(argv[1], '[')) single = 1;
for (; !status; hdupos++) /* Main loop through each extension */
{
fits_get_hdu_type(infptr, &hdutype, &status);
if (hdutype == IMAGE_HDU) {
/* get image dimensions and total number of pixels in image */
for (ii = 0; ii < 9; ii++)
naxes[ii] = 1;
fits_get_img_param(infptr, 9, &bitpix, &naxis, naxes, &status);
totpix = naxes[0] * naxes[1] * naxes[2] * naxes[3] * naxes[4]
* naxes[5] * naxes[6] * naxes[7] * naxes[8];
}
if (hdutype != IMAGE_HDU || naxis == 0 || totpix == 0) {
/* just copy tables and null images */
fits_copy_hdu(infptr, outfptr, 0, &status);
} else {
/* Explicitly create new image, to support compression */
fits_create_img(outfptr, bitpix, naxis, naxes, &status);
if (status) {
fits_report_error(stderr, status);
return(status);
}
/* copy all the user keywords (not the structural keywords) */
fits_get_hdrspace(infptr, &nkeys, NULL, &status);
for (ii = 1; ii <= nkeys; ii++) {
fits_read_record(infptr, ii, card, &status);
if (fits_get_keyclass(card) > TYP_CMPRS_KEY)
fits_write_record(outfptr, card, &status);
}
switch(bitpix) {
case BYTE_IMG:
datatype = TBYTE;
break;
case SHORT_IMG:
datatype = TSHORT;
break;
case LONG_IMG:
datatype = TINT;
break;
case FLOAT_IMG:
datatype = TFLOAT;
break;
case DOUBLE_IMG:
datatype = TDOUBLE;
break;
}
bytepix = abs(bitpix) / 8;
npix = totpix;
iteration = 0;
/* try to allocate memory for the entire image */
/* use double type to force memory alignment */
array = (double *) calloc(npix, bytepix);
/* if allocation failed, divide size by 2 and try again */
while (!array && iteration < 10) {
iteration++;
npix = npix / 2;
array = (double *) calloc(npix, bytepix);
}
if (!array) {
printf("Memory allocation error\n");
return(0);
}
/* turn off any scaling so that we copy the raw pixel values */
fits_set_bscale(infptr, bscale, bzero, &status);
fits_set_bscale(outfptr, bscale, bzero, &status);
first = 1;
while (totpix > 0 && !status)
{
/* read all or part of image then write it back to the output file */
fits_read_img(infptr, datatype, first, npix,
&nulval, array, &anynul, &status);
fits_write_img(outfptr, datatype, first, npix, array, &status);
totpix = totpix - npix;
first = first + npix;
}
free(array);
}
if (single) break; /* quit if only copying a single HDU */
fits_movrel_hdu(infptr, 1, NULL, &status); /* try to move to next HDU */
}
if (status == END_OF_FILE) status = 0; /* Reset after normal error */
fits_close_file(outfptr, &status);
fits_close_file(infptr, &status);
/* if error occurred, print out error message */
if (status)
fits_report_error(stderr, status);
return(status);
}
bool usImage::Load(const wxString& fname)
{
bool bError = false;
try
{
if (!wxFileExists(fname))
{
pFrame->Alert(_("File does not exist - cannot load ") + fname);
throw ERROR_INFO("File does not exist");
}
int status = 0; // CFITSIO status value MUST be initialized to zero!
fitsfile *fptr; // FITS file pointer
if (!PHD_fits_open_diskfile(&fptr, fname, READONLY, &status))
{
int hdutype;
if (fits_get_hdu_type(fptr, &hdutype, &status) || hdutype != IMAGE_HDU)
{
pFrame->Alert(_("FITS file is not of an image: ") + fname);
throw ERROR_INFO("Fits file is not an image");
}
// Get HDUs and size
int naxis = 0;
fits_get_img_dim(fptr, &naxis, &status);
long fsize[3];
fits_get_img_size(fptr, 2, fsize, &status);
int nhdus = 0;
fits_get_num_hdus(fptr, &nhdus, &status);
if ((nhdus != 1) || (naxis != 2)) {
pFrame->Alert(_("Unsupported type or read error loading FITS file ") + fname);
throw ERROR_INFO("unsupported type");
}
if (Init((int) fsize[0], (int) fsize[1]))
{
pFrame->Alert(_("Memory allocation error loading FITS file ") + fname);
throw ERROR_INFO("Memory Allocation failure");
}
long fpixel[3] = { 1, 1, 1 };
if (fits_read_pix(fptr, TUSHORT, fpixel, (int)(fsize[0] * fsize[1]), NULL, ImageData, NULL, &status)) { // Read image
pFrame->Alert(_("Error reading data from FITS file ") + fname);
throw ERROR_INFO("Error reading");
}
char *key = const_cast<char *>("EXPOSURE");
float exposure;
status = 0;
fits_read_key(fptr, TFLOAT, key, &exposure, NULL, &status);
if (status == 0)
ImgExpDur = (int) (exposure * 1000.0);
key = const_cast<char *>("STACKCNT");
int stackcnt;
status = 0;
fits_read_key(fptr, TINT, key, &stackcnt, NULL, &status);
if (status == 0)
ImgStackCnt = (int) stackcnt;
PHD_fits_close_file(fptr);
}
else
{
pFrame->Alert(_("Error opening FITS file ") + fname);
throw ERROR_INFO("error opening file");
}
}
catch (wxString Msg)
{
POSSIBLY_UNUSED(Msg);
bError = true;
}
return bError;
}
int main(int argc, char *argv[])
{
fitsfile *fptr = 0; /* FITS file pointer */
int status = 0; /* CFITSIO status value MUST be initialized to zero! */
int hdutype = 0, naxis = 0, ii = 0;
long naxes[2], totpix = 0, fpixel[2];
double *pix, sum = 0., meanval = 0., minval = 1.E33, maxval = -1.E33;
if (argc != 2) {
fprintf(stderr, "Usage: %s array \n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "Compute statistics of pixels in the input array\n");
fprintf(stderr, "\n");
fprintf(stderr, "Examples: \n");
fprintf(stderr, " imarith array.fits - the whole array\n");
fprintf(stderr, " imarith 'array.fits[200:210,300:310]' - array section\n");
fprintf(stderr, " imarith 'table.fits+1[bin (X,Y) = 4]' - array constructed\n");
fprintf(stderr, " from X and Y columns of a table, with 4-pixel bin size\n");
return (0);
}
if (!fits_open_image(&fptr, argv[1], READONLY, &status)) {
if (fits_get_hdu_type(fptr, &hdutype, &status) || hdutype != IMAGE_HDU) {
fprintf(stderr, "Error: this program only works on arrays, not tables\n");
return (1);
}
fits_get_img_dim(fptr, &naxis, &status);
fits_get_img_size(fptr, 2, naxes, &status);
if (status || naxis != 2) {
fprintf(stderr, "Error: NAXIS = %d. Only 2-D arrays are supported.\n", naxis);
return (1);
}
pix = (double *) malloc(naxes[0] * sizeof(double)); /* memory for 1 row */
if (pix == NULL) {
fprintf(stderr, "Memory allocation error\n");
return (1);
}
totpix = naxes[0] * naxes[1];
fpixel[0] = 1; /* read starting with first pixel in each row */
/* process array one row at a time; increment row # in each loop */
for (fpixel[1] = 1; fpixel[1] <= naxes[1]; fpixel[1]++) {
/* give starting pixel coordinate and number of pixels to read */
if (fits_read_pix(fptr, TDOUBLE, fpixel, naxes[0],0, pix,0, &status)) {
break; /* jump out of loop on error */
}
for (ii = 0; ii < naxes[0]; ii++) {
sum += pix[ii]; /* accumlate sum */
if (pix[ii] < minval) {
minval = pix[ii]; /* find min and */
}
if (pix[ii] > maxval) {
maxval = pix[ii]; /* max values */
}
}
}
free(pix);
fits_close_file(fptr, &status);
}
if (status) {
fits_report_error(stderr, status); /* print any error message */
} else {
if (totpix > 0) {
meanval = sum / totpix;
}
printf("Statistics of %ld x %ld array\n",
naxes[0], naxes[1]);
printf(" sum of pixels = %g\n", sum);
printf(" mean value = %g\n", meanval);
printf(" minimum value = %g\n", minval);
printf(" maximum value = %g\n", maxval);
}
return (status);
}
bool WMAPSource::initFile( )
{
bool bRetVal = true;
int iResult = 0;
_numFrames = 0;
if( !_filename.isNull( ) && !_filename.isEmpty( ) )
{
QString str;
fitsfile* ffits;
int iStatus = 0;
iResult = fits_open_file( &ffits, _filename.ascii( ), READONLY, &iStatus );
if( iResult == 0 )
{
int iNumHeaderDataUnits;
if( fits_get_num_hdus( ffits, &iNumHeaderDataUnits, &iStatus ) == 0 )
{
long lNumBaseRows = 0;
long lNumRows;
int iHDUType;
int i;
//
// determine the number of frames...
//
for( i=0; i<iNumHeaderDataUnits-1; i++ )
{
if( iStatus == 0 )
{
fits_get_hdu_type( ffits, &iHDUType, &iStatus );
if( iHDUType == BINARY_TBL || iHDUType == ASCII_TBL )
{
iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus );
if( iResult == 0 )
{
if( lNumBaseRows == 0 )
{
lNumBaseRows = lNumRows;
}
else if( lNumRows != 1 )
{
if( lNumRows < lNumBaseRows )
{
lNumBaseRows = lNumRows;
}
}
}
}
fits_movrel_hdu( ffits, 1, &iHDUType, &iStatus );
}
}
fits_movabs_hdu( ffits, 1, &iHDUType, &iStatus);
field *fld = new field;
fld->table = 0;
fld->column = 0;
fld->entry = 0;
fld->entries = 0;
fld->numSamplesPerFrame = 1;
fld->numFrames = lNumBaseRows;
_fields.insert( "INDEX", fld );
_fieldList.append( "INDEX" );
//
// add the fields and metadata...
//
for( i=0; i<iNumHeaderDataUnits-1; i++ )
{
if( iStatus == 0 )
{
addToMetadata( ffits, iStatus );
//
// create the field entries...
//
fits_get_hdu_type( ffits, &iHDUType, &iStatus );
if( iStatus == 0 )
{
if( iHDUType == BINARY_TBL || iHDUType == ASCII_TBL )
{
int iNumCols;
iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus );
if( iResult == 0 )
{
iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus );
if( iResult == 0 )
{
if( lNumRows > 1 )
{
addToFieldList( ffits, iNumCols, lNumRows, lNumBaseRows, iStatus );
}
else if( lNumRows == 1 )
{
addToMetadata( ffits, iNumCols, iStatus );
}
}
}
}
}
fits_movrel_hdu( ffits, 1, &iHDUType, &iStatus);
}
}
}
iStatus = 0;
updateNumFramesScalar( );
fits_close_file( ffits, &iStatus );
}
}
return bRetVal;
}
int main(int argc, char *argv[])
{
fitsfile *fptr; /* FITS file pointer */
int status = 0; /* CFITSIO status value MUST be initialized to zero! */
int hdutype, naxis, ii;
long naxes[2], totpix, fpixel[2], rowlen;
double *pix, sum = 0., medianval = 0.; //, minval = 1.E33, maxval = -1.E33;
double *medarray;
if (argc != 2) {
printf("Usage: imagemedian image \n");
printf("\n");
printf("Compute median of pixels in the input image\n");
printf("(Actually the median of the median of each row.)\n");
printf("\n");
printf("Examples: \n");
printf(" imagemedian image.fits - the whole image\n");
// printf(" imagemedian 'image.fits[200:210,300:310]' - image section\n");
// printf(" imagemedian 'table.fits+1[bin (X,Y) = 4]' - image constructed\n");
// printf(" from X and Y columns of a table, with 4-pixel bin size\n");
printf("\n");
return(0);
}
if ( !fits_open_file(&fptr, argv[1], READONLY, &status) )
{
if (fits_get_hdu_type(fptr, &hdutype, &status) || hdutype != IMAGE_HDU) {
printf("Error: this program only works on images, not tables\n");
return(1);
}
fits_get_img_dim(fptr, &naxis, &status);
fits_get_img_size(fptr, 2, naxes, &status);
if (status || naxis != 2) {
printf("Error: NAXIS = %d. Only 2-D images are supported.\n", naxis);
return(1);
}
pix = (double *) malloc(naxes[0] * sizeof(double)); /* memory for 1 row */
medarray = (double *) malloc(naxes[1] * sizeof(double)); /* memory for 1 column */
if (pix == NULL) {
printf("Memory allocation error\n");
return(1);
}
totpix = naxes[0] * naxes[1];
fpixel[0] = 1; /* read starting with first pixel in each row */
// printf("totpix: %lu\n", totpix);
// printf("fpixel: %lu\n", fpixel[0]);
// printf("fpixel: %lu\n", fpixel[1]);
// printf("Whole : %lu\n", naxes[0]);
// printf("Mod : %lu\n", naxes[0]%2);
// printf("Div : %lu\n", naxes[0]/2);
// printf("Whole : %lu\n", naxes[1]-1);
// printf("Mod : %lu\n", (naxes[1]-1)%2);
// printf("Div : %lu\n", (naxes[1]-1)/2);
/* process image one row at a time; increment row # in each loop */
for (fpixel[1] = 1; fpixel[1] <= naxes[1]; fpixel[1]++)
{
/* give starting pixel coordinate and number of pixels to read */
if (fits_read_pix(fptr, TDOUBLE, fpixel, naxes[0],0, pix,0, &status))
break; /* jump out of loop on error */
// compute row median and store then compute median of medians
// not perfect, but pretty close
// store in medianarray
medarray[fpixel[1]] = median ( pix, naxes[0] );
// printf("%g\n", medarray[fpixel[1]]);
// for (ii = 0; ii < naxes[0]; ii++) {
// sum += pix[ii]; /* accumlate sum */
// if (pix[ii] < minval) minval = pix[ii]; /* find min and */
// if (pix[ii] > maxval) maxval = pix[ii]; /* max values */
// }
}
free(pix);
fits_close_file(fptr, &status);
}
if (status) {
fits_report_error(stderr, status); /* print any error message */
}
else {
printf("%g\n", median ( medarray, naxes[1] ) );
// if (totpix > 0) meanval = sum / totpix;
//
// printf("Statistics of %ld x %ld image = %g\n",
// naxes[0], naxes[1]);
// printf(" sum of pixels = %g\n", sum);
// printf(" mean value = %g\n", meanval);
// printf(" minimum value = %g\n", minval);
// printf(" maximum value = %g\n", maxval);
}
return(status);
}
/* Print all the extension informations. */
void
fits_print_extension_info(struct fitsparams *p)
{
uint16_t *ui16;
fitsfile *fptr;
gal_data_t *cols=NULL, *tmp;
char **tstra, **estra, **sstra;
size_t i, numext, *dsize, ndim;
int j, nc, numhdu, hdutype, status=0, type;
char *msg, *tstr=NULL, sstr[1000], extname[FLEN_VALUE];
/* Open the FITS file and read the first extension type, upon moving to
the next extension, we will read its type, so for the first we will
need to do it explicitly. */
fptr=gal_fits_hdu_open(p->filename, "0", READONLY);
if (fits_get_hdu_type(fptr, &hdutype, &status) )
gal_fits_io_error(status, "reading first extension");
/* Get the number of HDUs. */
if( fits_get_num_hdus(fptr, &numhdu, &status) )
gal_fits_io_error(status, "finding number of HDUs");
numext=numhdu;
/* Allocate all the columns (in reverse order, since this is a simple
linked list). */
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_STRING, 1, &numext, NULL, 1,
p->cp.minmapsize, "HDU_SIZE", "name", "Size of "
"image or table number of rows and columns.");
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_STRING, 1, &numext, NULL, 1,
p->cp.minmapsize, "HDU_TYPE", "name", "Image "
"data type or `table' format (ASCII or binary).");
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_STRING, 1, &numext, NULL, 1,
p->cp.minmapsize, "EXTNAME", "name",
"Extension name of this HDU (EXTNAME in FITS).");
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_UINT16, 1, &numext, NULL, 1,
p->cp.minmapsize, "HDU_INDEX", "count", "Index "
"(starting from zero) of each HDU (extension).");
/* Keep pointers to the array of each column for easy writing. */
ui16 = cols->array;
estra = cols->next->array;
tstra = cols->next->next->array;
sstra = cols->next->next->next->array;
cols->next->disp_width=15;
cols->next->next->disp_width=15;
/* Fill in each column. */
for(i=0;i<numext;++i)
{
/* Work based on the type of the extension. */
switch(hdutype)
{
case IMAGE_HDU:
gal_fits_img_info(fptr, &type, &ndim, &dsize, NULL, NULL);
tstr=gal_type_name(type , 1);
break;
case ASCII_TBL:
case BINARY_TBL:
ndim=2;
tstr = hdutype==ASCII_TBL ? "table_ascii" : "table_binary";
dsize=gal_data_malloc_array(GAL_TYPE_SIZE_T, 2, __func__, "dsize");
gal_fits_tab_size(fptr, dsize+1, dsize);
break;
default:
error(EXIT_FAILURE, 0, "%s: a bug! the `hdutype' code %d not "
"recognized", __func__, hdutype);
}
/* Read the extension name*/
fits_read_keyword(fptr, "EXTNAME", extname, NULL, &status);
switch(status)
{
case 0:
gal_fits_key_clean_str_value(extname);
break;
case KEY_NO_EXIST:
sprintf(extname, "%s", GAL_BLANK_STRING);
status=0;
break;
default:
gal_fits_io_error(status, "reading EXTNAME keyword");
}
status=0;
/* Write the size into a string. `sprintf' returns the number of
written characters (excluding the `\0'). So for each dimension's
size that is written, we add to `nc' (the number of
characters). Note that FITS allows blank extensions, in those
cases, return "0". */
if(ndim>0)
{
nc=0;
for(j=ndim-1;j>=0;--j)
nc += sprintf(sstr+nc, "%zux", dsize[j]);
sstr[nc-1]='\0';
free(dsize);
}
else
{
sstr[0]='0';
sstr[1]='\0';
}
/* Write the strings into the columns. */
j=0;
for(tmp=cols; tmp!=NULL; tmp=tmp->next)
{
switch(j)
{
case 0: ui16[i]=i; break;
case 1: gal_checkset_allocate_copy(extname, estra+i); break;
case 2: gal_checkset_allocate_copy(tstr, tstra+i); break;
case 3: gal_checkset_allocate_copy(sstr, sstra+i); break;
}
++j;
}
/* Move to the next extension if we aren't on the last extension. */
if( i!=numext-1 && fits_movrel_hdu(fptr, 1, &hdutype, &status) )
{
asprintf(&msg, "moving to hdu %zu", i+1);
gal_fits_io_error(status, msg);
}
}
/* Print the resutls. */
if(!p->cp.quiet)
{
printf("%s\nRun on %s-----\n", PROGRAM_STRING, ctime(&p->rawtime));
printf("HDU (extension) information: `%s'.\n", p->filename);
printf(" Column 1: Index (counting from 0, usable with `--hdu').\n");
printf(" Column 2: Name (`EXTNAME' in FITS standard, usable with "
"`--hdu').\n");
printf(" Column 3: Image data type or `table' format (ASCII or "
"binary).\n");
printf(" Column 4: Size of data in HDU.\n");
printf("-----\n");
}
gal_table_write(cols, NULL, GAL_TABLE_FORMAT_TXT, NULL, NULL);
gal_list_data_free(cols);
}
bool PLANCKIDEFSource::initFile( )
{
bool bRetVal = true;
int iResult = 0;
_numFrames = 0;
if( !_filename.isNull( ) && !_filename.isEmpty( ) )
{
QString str;
fitsfile* ffits;
int iStatus = 0;
iResult = fits_open_file( &ffits, _filename.ascii( ), READONLY, &iStatus );
if( iResult == 0 )
{
int iNumHeaderDataUnits;
if( fits_get_num_hdus( ffits, &iNumHeaderDataUnits, &iStatus ) == 0 )
{
long lNumRows;
int iHDUType;
int i;
//
// determine the number of frames...
//
if( iNumHeaderDataUnits > 1 )
{
if( fits_movabs_hdu( ffits, 2, &iHDUType, &iStatus ) == 0 )
{
if( fits_get_hdu_type( ffits, &iHDUType, &iStatus ) == 0 )
{
if( iHDUType == BINARY_TBL )
{
iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus );
if( iResult == 0 )
{
_numFrames = lNumRows;
}
}
}
}
}
if( _numFrames > 0 )
{
fits_movabs_hdu( ffits, 1, &iHDUType, &iStatus );
field *fld = new field;
fld->table = 0;
fld->column = 0;
_fields.insert( "INDEX", fld );
_fieldList.append( "INDEX" );
//
// add the fields and metadata...
//
for( i=0; i<iNumHeaderDataUnits-1; i++ )
{
if( iStatus == 0 )
{
addToMetadata( ffits, iStatus );
//
// the first table never contains data...
//
if( i > 0 )
{
//
// create the time entries if necessary...
//
if( _fields.find( "TIME_ABSOLUTE" ) == 0L &&
_fields.find( "TIME_RELATIVE" ) == 0L )
{
char comment[FLEN_COMMENT];
int iStatusDelta = 0;
int iStatusZero = 0;
fits_read_key( ffits, TDOUBLE, "DELTA_T", &_dTimeDelta, comment, &iStatusDelta );
fits_read_key( ffits, TDOUBLE, "TIMEZERO", &_dTimeZero, comment, &iStatusZero );
if( iStatusDelta == 0 )
{
if( iStatusZero == 0 )
{
field *fld = new field;
fld->table = 0;
fld->column = 0;
_fields.insert( "TIME_ABSOLUTE", fld );
_fieldList.append( "TIME_ABSOLUTE" );
}
else
{
field *fld = new field;
fld->table = 0;
fld->column = 0;
_fields.insert( "TIME_RELATIVE", fld );
_fieldList.append( "TIME_RELATIVE" );
}
}
}
//
// create the field entries...
//
fits_get_hdu_type( ffits, &iHDUType, &iStatus );
if( iStatus == 0 )
{
if( iHDUType == BINARY_TBL || iHDUType == ASCII_TBL )
{
int iNumCols;
iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus );
if( iResult == 0 )
{
iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus );
if( iResult == 0 )
{
addToFieldList( ffits, iNumCols, iStatus );
}
}
}
}
}
fits_movrel_hdu( ffits, 1, &iHDUType, &iStatus);
}
}
}
}
iStatus = 0;
updateNumFramesScalar( );
fits_close_file( ffits, &iStatus );
}
}
return bRetVal;
}
int main(int argc, char *argv[])
{
fitsfile *fptr = 0; /* FITS file pointer, defined in fitsio.h */
char keyname[FLEN_KEYWORD], colname[FLEN_VALUE], coltype[FLEN_VALUE];
int status = 0; /* CFITSIO status value MUST be initialized to zero! */
int single = 0, hdupos = 0, hdutype = 0, bitpix = 0, naxis = 0, ncols = 0, ii = 0;
long naxes[10], nrows = 0;
int printhelp = (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0));
if (printhelp || argc != 2) {
fprintf(stderr, "Usage: %s filename[ext] \n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "List the structure of a single extension, or, if ext is \n");
fprintf(stderr, "not given, list the structure of the entire FITS file. \n");
fprintf(stderr, "\n");
fprintf(stderr, "Note that it may be necessary to enclose the input file\n");
fprintf(stderr, "name in single quote characters on the Unix command line.\n");
return (0);
}
FILE *fout = popen(PAGER, "w");
if (fout == NULL) {
fprintf(stderr, "Could not execute '%s'\n", PAGER);
return (1);
}
if (!fits_open_file(&fptr, argv[1], READONLY, &status)) {
fits_get_hdu_num(fptr, &hdupos); /* Get the current HDU position */
/* List only a single structure if a specific extension was given */
if (strchr(argv[1], '[') || strchr(argv[1], '+')) {
single++;
}
for (; !status; hdupos++) { /* Main loop for each HDU */
fits_get_hdu_type(fptr, &hdutype, &status); /* Get the HDU type */
fprintf(fout, "\nHDU #%d ", hdupos);
if (hdutype == IMAGE_HDU) { /* primary array or image HDU */
fits_get_img_param(fptr, 10, &bitpix, &naxis, naxes, &status);
fprintf(fout, "Array: NAXIS = %d, BITPIX = %d\n", naxis, bitpix);
for (ii = 0; ii < naxis; ii++) {
fprintf(fout, " NAXIS%d = %ld\n",ii+1, naxes[ii]);
}
} else { /* a table HDU */
fits_get_num_rows(fptr, &nrows, &status);
fits_get_num_cols(fptr, &ncols, &status);
if (hdutype == ASCII_TBL) {
fprintf(fout, "ASCII Table: ");
} else {
fprintf(fout, "Binary Table: ");
}
fprintf(fout, "%d columns x %ld rows\n", ncols, nrows);
fprintf(fout, " COL NAME FORMAT\n");
for (ii = 1; ii <= ncols; ii++) {
fits_make_keyn("TTYPE", ii, keyname, &status); /* make keyword */
fits_read_key(fptr, TSTRING, keyname, colname, NULL, &status);
fits_make_keyn("TFORM", ii, keyname, &status); /* make keyword */
fits_read_key(fptr, TSTRING, keyname, coltype, NULL, &status);
fprintf(fout, " %3d %-16s %-16s\n", ii, colname, coltype);
}
}
if (single) {
break; /* quit if only listing a single HDU */
}
fits_movrel_hdu(fptr, 1, NULL, &status); /* try move to next ext */
}
if (status == END_OF_FILE) {
status = 0; /* Reset normal error */
}
fits_close_file(fptr, &status);
}
pclose(fout);
if (status) {
fits_report_error(stderr, status); /* print any error message */
}
return (status);
}
bool Camera_INDIClass::ReadFITS(usImage& img, bool takeSubframe, const wxRect& subframe)
{
int xsize, ysize;
fitsfile *fptr; // FITS file pointer
int status = 0; // CFITSIO status value MUST be initialized to zero!
int hdutype, naxis;
int nhdus=0;
long fits_size[2];
long fpixel[3] = {1,1,1};
size_t bsize = static_cast<size_t>(cam_bp->bloblen);
// load blob to CFITSIO
if (fits_open_memfile(&fptr,
"",
READONLY,
&(cam_bp->blob),
&bsize,
0,
NULL,
&status) )
{
pFrame->Alert(_("Unsupported type or read error loading FITS file"));
return true;
}
if (fits_get_hdu_type(fptr, &hdutype, &status) || hdutype != IMAGE_HDU) {
pFrame->Alert(_("FITS file is not of an image"));
PHD_fits_close_file(fptr);
return true;
}
// Get HDUs and size
fits_get_img_dim(fptr, &naxis, &status);
fits_get_img_size(fptr, 2, fits_size, &status);
xsize = (int) fits_size[0];
ysize = (int) fits_size[1];
fits_get_num_hdus(fptr,&nhdus,&status);
if ((nhdus != 1) || (naxis != 2)) {
pFrame->Alert(_("Unsupported type or read error loading FITS file"));
PHD_fits_close_file(fptr);
return true;
}
if (takeSubframe) {
if (img.Init(FullSize)) {
pFrame->Alert(_("Memory allocation error"));
PHD_fits_close_file(fptr);
return true;
}
img.Clear();
img.Subframe = subframe;
unsigned short *rawdata = new unsigned short[xsize*ysize];
if (fits_read_pix(fptr, TUSHORT, fpixel, xsize*ysize, NULL, rawdata, NULL, &status) ) {
pFrame->Alert(_("Error reading data"));
PHD_fits_close_file(fptr);
return true;
}
int i = 0;
for (int y = 0; y < subframe.height; y++)
{
unsigned short *dataptr = img.ImageData + (y + subframe.y) * img.Size.GetWidth() + subframe.x;
memcpy(dataptr, &rawdata[i], subframe.width * sizeof(unsigned short));
i += subframe.width;
}
delete[] rawdata;
}
else {
if (img.Init(xsize,ysize)) {
pFrame->Alert(_("Memory allocation error"));
PHD_fits_close_file(fptr);
return true;
}
// Read image
if (fits_read_pix(fptr, TUSHORT, fpixel, xsize*ysize, NULL, img.ImageData, NULL, &status) ) {
pFrame->Alert(_("Error reading data"));
PHD_fits_close_file(fptr);
return true;
}
}
PHD_fits_close_file(fptr);
return false;
}
static GwyContainer*
fits_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
fitsfile *fptr = NULL;
GwyDataField *field = NULL, *mask;
gint status = 0; /* Must be initialised to zero! */
gint hdutype, naxis, anynull, nkeys, k;
glong res[3]; /* First index is the fast looping one. */
char strvalue[FLEN_VALUE];
gchar *invalid = NULL;
gdouble real, off;
if (fits_open_image(&fptr, filename, READONLY, &status)) {
err_FITS(error, status);
return NULL;
}
if (fits_get_hdu_type(fptr, &hdutype, &status)) {
err_FITS(error, status);
goto fail;
}
gwy_debug("hdutype %d", hdutype);
if (hdutype != IMAGE_HDU) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Only two-dimensional images are supported."));
goto fail;
}
if (fits_get_img_dim(fptr, &naxis, &status)) {
err_FITS(error, status);
goto fail;
}
gwy_debug("naxis %d", naxis);
if (naxis != 2 && naxis != 3) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Only two-dimensional images are supported."));
goto fail;
}
if (fits_get_img_size(fptr, naxis, res, &status)) {
err_FITS(error, status);
goto fail;
}
if (naxis == 3 && res[2] != 1) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Only two-dimensional images are supported."));
goto fail;
}
gwy_debug("xres %ld, yres %ld", res[0], res[1]);
if (err_DIMENSION(error, res[0]) || err_DIMENSION(error, res[1]))
goto fail;
field = gwy_data_field_new(res[0], res[1], res[0], res[1], FALSE);
invalid = g_new(gchar, res[0]*res[1]);
if (fits_read_imgnull(fptr, TDOUBLE, 1, res[0]*res[1],
field->data, invalid, &anynull, &status)) {
err_FITS(error, status);
goto fail;
}
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", field);
/* Failures here are non-fatal. We already have an image. */
if (fits_get_hdrspace(fptr, &nkeys, NULL, &status)) {
g_warning("Cannot get the first hdrspace.");
goto fail;
}
if (!fits_read_key(fptr, TSTRING, "BUINT ", strvalue, NULL, &status)) {
gint power10;
gwy_debug("BUINT = <%s>", strvalue);
gwy_si_unit_set_from_string_parse(gwy_data_field_get_si_unit_z(field),
strvalue, &power10);
if (power10)
gwy_data_field_multiply(field, pow10(power10));
}
status = 0;
if (get_real_and_offset(fptr, 1, res[0], &real, &off)) {
if (real < 0.0) {
off += real;
real = -real;
gwy_data_field_invert(field, FALSE, TRUE, FALSE);
}
gwy_data_field_set_xreal(field, real);
gwy_data_field_set_xoffset(field, off);
}
if (get_real_and_offset(fptr, 2, res[1], &real, &off)) {
if (real < 0.0) {
off += real;
real = -real;
gwy_data_field_invert(field, TRUE, FALSE, FALSE);
}
gwy_data_field_set_yreal(field, real);
gwy_data_field_set_yoffset(field, off);
}
/* Create a mask of invalid data. */
for (k = 0; k < field->xres*field->yres; k++) {
if (invalid[k])
field->data[k] = NAN;
}
if ((mask = gwy_app_channel_mask_of_nans(field, TRUE))) {
gwy_container_set_object_by_name(container, "/0/mask", mask);
g_object_unref(mask);
}
fail:
fits_close_file(fptr, &status);
gwy_object_unref(field);
g_free(invalid);
return container;
}
