image_t *readimage(const char *filename) { char errmsg[80]; image_t *image = NULL; // open the FITS file int status = 0; fitsfile *fits = NULL; if (fits_open_file(&fits, filename, READONLY, &status)) { fits_get_errstatus(status, errmsg); fprintf(stderr, "cannot read fits file %s: %s\n", filename, errmsg); return NULL; } // find dimensions of pixel array int igt; int naxis; long naxes[3]; if (fits_get_img_param(fits, 3, &igt, &naxis, naxes, &status)) { fits_get_errstatus(status, errmsg); fprintf(stderr, "cannot read fits file info: %s\n", errmsg); goto bad; } image = (image_t *)malloc(sizeof(image_t)); image->width = naxes[0]; image->height = naxes[1]; // read the pixel data long npixels = image->width * image->height; image->data = (double *)malloc(npixels * sizeof(double)); long firstpixel[3] = { 1, 1, 1 }; if (fits_read_pix(fits, TDOUBLE, firstpixel, npixels, NULL, image->data, NULL, &status)) { fits_get_errstatus(status, errmsg); fprintf(stderr, "cannot read pixel data: %s\n", errmsg); goto bad; } // close the file if (fits_close_file(fits, &status)) { fits_get_errstatus(status, errmsg); fprintf(stderr, "cannot close fits file %s: %s\n", filename, errmsg); goto bad; } // return the image return image; bad: if (image) { if (image->data) { free(image->data); } free(image); } if (fits) { fits_close_file(fits, &status); } return NULL; }
static void write_pixels(oskar_Mem* data, const char* filename, int width, int height, int num_planes, int i_plane, int* status) { long naxes[3], firstpix[3], num_pix; int dims_ok = 0; fitsfile* f = 0; if (*status) return; if (oskar_file_exists(filename)) { int naxis = 0, imagetype = 0; fits_open_file(&f, filename, READWRITE, status); fits_get_img_param(f, 3, &imagetype, &naxis, naxes, status); if (naxis == 3 && naxes[0] == width && naxes[1] == height && naxes[2] == num_planes) { dims_ok = 1; } else { *status = 0; fits_close_file(f, status); remove(filename); f = 0; } } if (!dims_ok) { naxes[0] = width; naxes[1] = height; naxes[2] = num_planes; fits_create_file(&f, filename, status); fits_create_img(f, oskar_mem_is_double(data) ? DOUBLE_IMG : FLOAT_IMG, 3, naxes, status); } if (*status || !f) { if (f) fits_close_file(f, status); *status = OSKAR_ERR_FILE_IO; return; } num_pix = width * height; firstpix[0] = 1; firstpix[1] = 1; firstpix[2] = 1 + i_plane; if (i_plane < 0) { firstpix[2] = 1; num_pix *= num_planes; } fits_write_pix(f, oskar_mem_is_double(data) ? TDOUBLE : TFLOAT, firstpix, num_pix, oskar_mem_void(data), status); fits_close_file(f, status); }
int read_and_process(char* path) { fitsfile *fptr; int status = 0; unsigned int bitpix, naxis; long naxes[3]; long nelements; int anynul; unsigned char* image; if (!fits_open_file(&fptr, path, READONLY, &status)) { if (!fits_get_img_param(fptr, 2, &bitpix, &naxis, naxes, &status) ) { if (naxis != 3){ printf("Not a 3D fits\n"); return -1; } if (bitpix != 8){ printf("Process only 8 bit fits\n"); return -1; } printf("bitpix=%d naxes=%d width=%ld height=%ld\n",bitpix,naxis,naxes[0],naxes[1]); nelements = naxes[0]*naxes[1]; if (width==0 && height==0){ width = naxes[0]; height = naxes[1]; } else { if (width != naxes[0] || height != naxes[1]){ printf("naxes error: %ldx%ld instead of %ldx%ld\n",naxes[0],naxes[1],width,height); return -1; } } image = malloc(sizeof(unsigned char)*nelements); fits_read_img(fptr,TBYTE,1,nelements,NULL,image, &anynul, &status); write_fits("red.fits",image); fits_read_img(fptr,TBYTE,nelements +1,nelements,NULL,image, &anynul, &status); write_fits("green.fits",image); fits_read_img(fptr,TBYTE,2* nelements +1,nelements,NULL,image, &anynul, &status); write_fits("blue.fits",image); fits_close_file(fptr, &status); free(image); return status; } } return -1; }
double get_average(std::string filename) { fitsfile *fptr; /* FITS file pointer, defined in fitsio.h */ int status = 0; /* CFITSIO status value MUST be initialized to zero! */ int bitpix, naxis, ii; long naxes[2] = {1,1}, fpixel[2] = {1,1}; double *pixels; std::vector<double> values; //stores the values of all pixels in image if (!fits_open_file(&fptr, filename.c_str(), READONLY, &status)) { if (!fits_get_img_param(fptr, 2, &bitpix, &naxis, naxes, &status) ) { if (naxis > 2 || naxis == 0) printf("Error: only 1D or 2D images are supported\n"); else { /* get memory for 1 row */ pixels = (double *) malloc(naxes[0] * sizeof(double)); if (pixels == NULL) { printf("Memory allocation error\n"); return(1); } /* loop over all the rows in the image, top to bottom */ for (fpixel[1] = naxes[1]; fpixel[1] >= 1; fpixel[1]--) { if (fits_read_pix(fptr, TDOUBLE, fpixel, naxes[0], NULL, pixels, NULL, &status) ) /* read row of pixels */ break; /* jump out of loop on error */ for (ii = 0; ii < naxes[0]; ii++) { values.push_back(pixels[ii]); } } free(pixels); } } fits_close_file(fptr, &status); } if (status) fits_report_error(stderr, status); /* print any error message */ //report average of values double sum = 0; for (int i=0; i < values.size(); i++) sum += values[i]; return sum/values.size(); }
int read_fits(char* path, unsigned char** image) { fitsfile *fptr; int status = 0; unsigned int bitpix, naxis; long naxes[2]; long nelements; int anynul; if (!fits_open_file(&fptr, path, READONLY, &status)) { if (!fits_get_img_param(fptr, 2, &bitpix, &naxis, naxes, &status) ) { printf("bitpix=%d naxes=%d width=%ld height=%ld\n",bitpix,naxis,naxes[0],naxes[1]); nelements = naxes[0]*naxes[1]; if (width==0 && height==0){ width = naxes[0]; height = naxes[1]; } else { if (width != naxes[0] || height != naxes[1]){ printf("naxes error: %ldx%ld instead of %ldx%ld\n",naxes[0],naxes[1],width,height); return -1; } } if (naxis != 2){ printf("Process only 2D fits\n"); fits_close_file(fptr, &status); return -1; } if (bitpix != 8){ printf("Process only 8 bit fits\n"); fits_close_file(fptr, &status); return -1; } *image = malloc(sizeof(unsigned char)*nelements); if (bitpix == 8){ fits_read_img(fptr,TBYTE,1,nelements,NULL,*image, &anynul, &status); fits_close_file(fptr, &status); if (status != 0) printf("status = %d\n",status); return status; } } } return -1; }
/* Load dimension params from fits file */ int cyclic_load_params(fitsfile *f, struct cyclic_work *w, int *status) { int bitpix, naxis; long naxes[4]; fits_get_img_param(f, 4, &bitpix, &naxis, naxes, status); if (naxis!=4) { return(-1); } w->nphase = naxes[0]; w->npol = naxes[1]; w->nchan = naxes[2]; w->nlag = 0; w->nharm = 0; return(*status); }
void InputFileFITS::_readImage(Image<T>& buff, int type) { int status = 0; if(!isOpened()) throwException("Error in InputFileFITS::readImage() ", status); int bitpix; int naxis; const int MAXDIM = 3; long naxes[MAXDIM]; fits_get_img_param(infptr, MAXDIM, &bitpix, &naxis, naxes, &status); if(!isOpened()) throwException("Error in InputFileFITS::readImage() ", status); long fpixel[MAXDIM]; long nelements = 1; for(int dim=0; dim<naxis; dim++) { fpixel[dim] = 1; nelements *= naxes[dim]; } long nulval = 0; int anynul; buff.data.resize(nelements); fits_read_pix(infptr, type, fpixel, nelements, &nulval, &buff.data[0], &anynul, &status); if(!isOpened()) throwException("Error in InputFileFITS::readImage() ", status); buff.dim = naxis; buff.sizes.resize(0); for(int i=0; i<naxis; i++) buff.sizes.push_back(naxes[i]); }
int main(int argc, char **argv) { int i, iarg, nPix, anynul, status, mask; char help[4096]; fitsfile *iPtr; int iBitpix, iNaxis; long iNaxes[MAXDIM]; float *iRData=NULL; fitsfile *mPtr; int mBitpix, mNaxis; long mNaxes[MAXDIM]; int *mRData=NULL; char *inim=NULL, *maskim=NULL, *outim=NULL; float fillVal=D_FILLVAL; /* START */ status = 0; mask = D_MASK; fillVal = D_FILLVAL; sprintf(help, "Usage : maskim [options]\n"); sprintf(help, "%sRequired options:\n", help); sprintf(help, "%s [-inim fitsfile] : input image\n", help); sprintf(help, "%s [-maskim fitsfile]: corresponding mask image\n", help); sprintf(help, "%s [-outim fitsfile] : output masked image\n\n", help); sprintf(help, "%sOptions:\n", help); sprintf(help, "%s [-fi fillval] : Value of filled pixels (%.3f)\n", help, fillVal); sprintf(help, "%s [-mask hex] : Mask for bad pixels (0x%x)\n", help, mask); /* read in command options. j counts # of required args given */ for (iarg=1; iarg < argc; iarg++) { if (argv[iarg][0]=='-') { if (strcasecmp(argv[iarg]+1,"inim")==0) { inim = argv[++iarg]; } else if (strcasecmp(argv[iarg]+1,"maskim")==0) { maskim = argv[++iarg]; } else if (strcasecmp(argv[iarg]+1,"outim")==0) { outim = argv[++iarg]; } else if (strcasecmp(argv[iarg]+1,"fi")==0) { sscanf(argv[++iarg], "%f", &fillVal); } else if (strcasecmp(argv[iarg]+1,"mask")==0) { sscanf(argv[++iarg], "%d", &mask); } else { fprintf(stderr, "Unknown option : %s\n", argv[iarg]); exit(1); } } else { fprintf(stderr, "Unexpected string encountered on command line : %s\n", argv[iarg]); exit(1); } } /* read in command options */ if (argc < 2) { fprintf(stderr, "%s\n", help); exit(1); } /* insanity checking */ if ( !(inim) ) { fprintf(stderr, "FATAL ERROR inim is required command line option\n"); exit(1); } if ( !(maskim) ) { fprintf(stderr, "FATAL ERROR maskim is required command line option\n"); exit(1); } if ( !(outim) ) { fprintf(stderr, "FATAL ERROR outim is required command line option\n"); exit(1); } /* open up, get bitpix, # dimensions, image size */ if ( fits_open_file(&iPtr, inim, 0, &status) || fits_get_img_param(iPtr, 2, &iBitpix, &iNaxis, iNaxes, &status) ) { printError(status); } if ( fits_open_file(&mPtr, maskim, 0, &status) || fits_get_img_param(mPtr, 2, &mBitpix, &mNaxis, mNaxes, &status) ) { printError(status); } assert(iNaxes[0] == mNaxes[0]); assert(iNaxes[1] == mNaxes[1]); nPix = iNaxes[0]*iNaxes[1]; iRData = (float *)realloc(iRData, nPix*sizeof(float)); mRData = (int *)realloc(mRData, nPix*sizeof(int)); if (iRData == NULL || mRData == NULL) { fprintf(stderr, "Cannot Allocate Standard Data Arrays\n"); exit (1); } memset(iRData, 0.0, nPix*sizeof(float)); memset(mRData, 0x0, nPix*sizeof(int)); if (fits_read_img(iPtr, TFLOAT, 1, nPix, 0, iRData, &anynul, &status) || fits_read_img(mPtr, TINT, 1, nPix, 0, mRData, &anynul, &status) || fits_close_file(mPtr, &status)) printError(status); /* do the masking */ for (i = nPix; i--; ) if (mRData[i] & mask) iRData[i] = fillVal; /* reuse mptr and help */ sprintf(help, "!%s", outim); if (fits_create_template(&mPtr, help, inim, &status) || fits_write_img(mPtr, TFLOAT, 1, nPix, iRData, &status) || fits_close_file(mPtr, &status) || fits_close_file(iPtr, &status)) printError(status); free(iRData); free(mRData); return 0; }
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); }
std::vector<ImportDescriptor*> FitsImporter::getImportDescriptors(const std::string& fname) { std::string filename = fname; std::vector<std::vector<std::string> >& errors = mErrors[fname]; std::vector<std::vector<std::string> >& warnings = mWarnings[fname]; errors.clear(); warnings.clear(); int status=0; std::vector<ImportDescriptor*> descriptors; FitsFileResource pFile(filename); if (!pFile.isValid()) { errors.resize(1); errors[0].push_back(pFile.getStatus()); RETURN_DESCRIPTORS; } int hduCnt = 0; int specificHdu = 0; int hdu = 1; if (!splitFilename(filename, hduCnt, specificHdu, hdu, pFile, errors, warnings)) { RETURN_DESCRIPTORS; } errors.resize(hduCnt+1); warnings.resize(hduCnt+1); for(; hdu <= hduCnt; ++hdu) { std::string datasetName = filename + "[" + StringUtilities::toDisplayString(hdu) + "]"; int hduType; CHECK_FITS(fits_movabs_hdu(pFile, hdu, &hduType, &status), hdu, false, continue); ImportDescriptorResource pImportDescriptor(static_cast<ImportDescriptor*>(NULL)); FactoryResource<DynamicObject> pMetadata; VERIFYRV(pMetadata.get() != NULL, descriptors); { // scope std::vector<std::string> comments; char pCard[81]; char pValue[81]; char pComment[81]; int nkeys = 0; CHECK_FITS(fits_get_hdrspace(pFile, &nkeys, NULL, &status), hdu, true, ;); for(int keyidx = 1; keyidx <= nkeys; ++keyidx) { CHECK_FITS(fits_read_keyn(pFile, keyidx, pCard, pValue, pComment, &status), hdu, true, continue); std::string name = StringUtilities::stripWhitespace(std::string(pCard)); std::string val = StringUtilities::stripWhitespace(std::string(pValue)); std::string comment = StringUtilities::stripWhitespace(std::string(pComment)); if (!val.empty()) { pMetadata->setAttributeByPath("FITS/" + name, val); } else if (!comment.empty()) { comments.push_back(comment); } } if (!comments.empty()) { // ideally, this would add a multi-line string but Opticks doesn't display this properly // pMetadata->setAttributeByPath("FITS/COMMENT", StringUtilities::join(comments, "\n")); for(unsigned int idx = 0; idx < comments.size(); ++idx) { pMetadata->setAttributeByPath("FITS/COMMENT/" + StringUtilities::toDisplayString(idx), comments[idx]); } } } switch(hduType) { case IMAGE_HDU: { pImportDescriptor = ImportDescriptorResource(datasetName, TypeConverter::toString<RasterElement>()); VERIFYRV(pImportDescriptor.get() != NULL, descriptors); EncodingType fileEncoding; InterleaveFormatType interleave(BSQ); unsigned int rows=0; unsigned int cols=0; unsigned int bands=1; int bitpix; int naxis; long axes[3]; CHECK_FITS(fits_get_img_param(pFile, 3, &bitpix, &naxis, axes, &status), hdu, false, continue); switch(bitpix) { case BYTE_IMG: fileEncoding = INT1UBYTE; break; case SHORT_IMG: fileEncoding = INT2SBYTES; break; case LONG_IMG: fileEncoding = INT4SBYTES; break; case FLOAT_IMG: fileEncoding = FLT4BYTES; break; case DOUBLE_IMG: fileEncoding = FLT8BYTES; break; default: warnings[hdu].push_back("Unsupported BITPIX value " + StringUtilities::toDisplayString(bitpix) + "."); continue; } EncodingType dataEncoding = checkForOverflow(fileEncoding, pMetadata.get(), hdu, errors, warnings); if (naxis == 1) { // 1-D data is a signature pImportDescriptor = ImportDescriptorResource(datasetName, TypeConverter::toString<Signature>()); pMetadata->setAttributeByPath(METADATA_SIG_ENCODING, dataEncoding); pMetadata->setAttributeByPath(METADATA_SIG_LENGTH, axes[0]); RasterUtilities::generateAndSetFileDescriptor(pImportDescriptor->getDataDescriptor(), filename, StringUtilities::toDisplayString(hdu), BIG_ENDIAN_ORDER); // add units SignatureDataDescriptor* pSigDd = dynamic_cast<SignatureDataDescriptor*>(pImportDescriptor->getDataDescriptor()); if (pSigDd != NULL) { FactoryResource<Units> pUnits; pUnits->setUnitName("Custom"); pUnits->setUnitType(CUSTOM_UNIT); pSigDd->setUnits("Reflectance", pUnits.get()); } break; // leave switch() } else if (naxis == 2) { cols = axes[0]; rows = axes[1]; } else if (naxis == 3) { cols = axes[0]; rows = axes[1]; bands = axes[2]; } else { errors[hdu].push_back(StringUtilities::toDisplayString(naxis) + " axis data not supported."); } RasterDataDescriptor* pDataDesc = RasterUtilities::generateRasterDataDescriptor( datasetName, NULL, rows, cols, bands, interleave, dataEncoding, IN_MEMORY); pImportDescriptor->setDataDescriptor(pDataDesc); if (specificHdu == 0 && hdu == 1 && naxis == 2 && (axes[0] <= 5 || axes[1] <= 5)) { // use 5 as this is a good top end for the number of astronomical band pass filters // in general usage. this is not in a spec anywhere and is derived from various sample // FITS files for different astronomical instruments. // // There's a good chance this is really a spectrum. (0th HDU) // We'll create an import descriptor for the spectrum version of this // And disable the raster descriptor by default pImportDescriptor->setImported(false); ImportDescriptorResource pSigDesc(datasetName, TypeConverter::toString<SignatureLibrary>()); DynamicObject* pSigMetadata = pSigDesc->getDataDescriptor()->getMetadata(); pSigMetadata->merge(pMetadata.get()); std::vector<double> centerWavelengths; unsigned int cnt = (axes[0] <= 5) ? axes[1] : axes[0]; double startVal = StringUtilities::fromDisplayString<double>( dv_cast<std::string>(pMetadata->getAttributeByPath("FITS/MINWAVE"), "0.0")); double endVal = StringUtilities::fromDisplayString<double>( dv_cast<std::string>(pMetadata->getAttributeByPath("FITS/MAXWAVE"), "0.0")); double incr = (endVal == 0.0) ? 1.0 : ((endVal - startVal) / static_cast<double>(cnt)); centerWavelengths.reserve(cnt); for (unsigned int idx = 0; idx < cnt; idx++) { centerWavelengths.push_back(startVal + (idx * incr)); } pSigMetadata->setAttributeByPath(CENTER_WAVELENGTHS_METADATA_PATH, centerWavelengths); // Units std::string unitsName = dv_cast<std::string>(pMetadata->getAttributeByPath("FITS/BUNIT"), std::string()); if (!unitsName.empty()) { FactoryResource<Units> units; units->setUnitName(unitsName); units->setUnitType(RADIANCE); SignatureDataDescriptor* pSigDd = dynamic_cast<SignatureDataDescriptor*>(pSigDesc->getDataDescriptor()); if (pSigDd != NULL) { pSigDd->setUnits("Reflectance", units.get()); } } RasterUtilities::generateAndSetFileDescriptor(pSigDesc->getDataDescriptor(), filename, StringUtilities::toDisplayString(hdu), BIG_ENDIAN_ORDER); // If units are not available, set custom units into the data descriptor so that the user can // modify them - this must occur after the call to RasterUtilities::generateAndSetFileDescriptor() // so that the file descriptor will still display no defined units if (unitsName.empty()) { FactoryResource<Units> units; units->setUnitName("Custom"); units->setUnitType(CUSTOM_UNIT); SignatureDataDescriptor* pSigDd = dynamic_cast<SignatureDataDescriptor*>(pSigDesc->getDataDescriptor()); if (pSigDd != NULL) { pSigDd->setUnits("Reflectance", units.get()); } } descriptors.push_back(pSigDesc.release()); } RasterFileDescriptor* pFileDescriptor = dynamic_cast<RasterFileDescriptor*>( RasterUtilities::generateAndSetFileDescriptor(pDataDesc, filename, StringUtilities::toDisplayString(hdu), BIG_ENDIAN_ORDER)); if (pFileDescriptor != NULL) { unsigned int bitsPerElement = RasterUtilities::bytesInEncoding(fileEncoding) * 8; pFileDescriptor->setBitsPerElement(bitsPerElement); } break; // leave switch() } case ASCII_TBL: case BINARY_TBL: warnings[hdu].push_back("Tables not supported. [HDU " + StringUtilities::toDisplayString(hdu) + "]"); continue; default: warnings[hdu].push_back("HDU " + StringUtilities::toDisplayString(hdu) + " is an unknown type."); continue; } pImportDescriptor->getDataDescriptor()->setMetadata(pMetadata.release()); pImportDescriptor->setImported(errors[hdu].empty()); descriptors.push_back(pImportDescriptor.release()); }
void readFITS(const std::string& fitsname, cv::Mat& cvImage) { fitsfile *fptr = nullptr; int status(0); char err_text[100]; //READONLY, READWRITE fits_open_file(&fptr, fitsname.c_str(), READONLY, &status); if (status) { fits_report_error(stdout, status); fits_get_errstatus(status,err_text); fptr = nullptr; std::cout << "readFITS: Unable to open the fits file." << std::endl; throw CustomException("readFITS: Unable to open the fits file."); } //turn off scaling so we read the raw pixel value double bscale_ = 1.0, bzero_ = 0.0; fits_set_bscale(fptr, bscale_, bzero_, &status); int bitpix, naxis; int maxdim(3); long naxes[] = {1,1, 1}; fits_get_img_param(fptr, maxdim, &bitpix, &naxis, naxes, &status); if (status) { fits_report_error(stdout, status); fits_get_errstatus(status,err_text); fptr = nullptr; std::cout << "readFITS: Unable to get params from FITS." << std::endl; throw CustomException("readFITS: Unable to get params from FITS."); } if(naxis == 2) { // TBYTE, TSBYTE, TSHORT, TUSHORT, TINT, TUINT, TLONG, TLONGLONG, TULONG, TFLOAT, TDOUBLE long fpixel[] = {1, 1}; long lpixel[] = {naxes[0], naxes[1]}; long inc[] = {1, 1}; long nelements = naxes[0] * naxes[1]; double *array = new double[nelements]; fits_read_subset(fptr, TDOUBLE, fpixel, lpixel, inc, nullptr, array, nullptr, &status); if (status) { fits_report_error(stdout, status); fits_get_errstatus(status,err_text); fptr = nullptr; delete[] array; throw CustomException("readFITS: Unable to read the fits file."); } //it seems cfitsio interprets image axes in the oppsite way of opencv cvImage = cv::Mat(naxes[1], naxes[0], cv::DataType<double>::type, array); fits_close_file(fptr, &status); if (status) { fits_report_error(stdout, status); fits_get_errstatus(status,err_text); fptr = nullptr; delete[] array; throw CustomException("readFITS: Cannot close fits file."); } } if(naxis == 3) { // TBYTE, TSBYTE, TSHORT, TUSHORT, TINT, TUINT, TLONG, TLONGLONG, TULONG, TFLOAT, TDOUBLE long layer = 29; //Only consider the first layer long fpixel[] = {1, 1, layer}; long lpixel[] = {naxes[0], naxes[1], layer}; long inc[] = {1, 1, 1}; long nelements = naxes[0] * naxes[1]; double *array = new double[nelements]; fits_read_subset(fptr, TDOUBLE, fpixel, lpixel, inc, nullptr, array, nullptr, &status); if (status) { fits_report_error(stdout, status); fits_get_errstatus(status,err_text); fptr = nullptr; delete[] array; throw CustomException("readFITS: Unable to read the fits file."); } //it seems cfitsio interprets image axes in the oppsite way of opencv cvImage = cv::Mat(naxes[1], naxes[0], cv::DataType<double>::type, array); fits_close_file(fptr, &status); if (status) { fits_report_error(stdout, status); fits_get_errstatus(status,err_text); fptr = nullptr; delete[] array; throw CustomException("readFITS: Cannot close fits file."); } } }
/* Function to write array to FITS file, and copy header info from other file */ void fitswrap_write2file(char *fileout, char *copyhdr, double **array, long write_size[2], int *status){ /* Variable Declarations & Initializations */ int k,naxis,bitpix; long fpixel[2],naxes[2],bzero; char buf_date[FLEN_VALUE],buf_time[FLEN_VALUE],*mod_comm; fitsfile *fitsfp,*hdrfp; time_t now; struct tm *ptr; *status = 0; /* Open file from which header will be copied */ hdrfp = fitswrap_open_read(copyhdr, status); /* Check for output file -- create & open for write */ if(access(fileout,F_OK) == 0) // Check if output file exists remove(fileout); // If yes, remove it if(fits_create_file(&fitsfp, fileout, status)){ fitswrap_catcherror(status); // Send pointer not value } mod_comm = "Modified by fitswrap routine, TPEB."; /* Copy header from copyhdr FITS file. */ fits_copy_header(hdrfp, fitsfp, status); // Copy header from input FITS fits_get_img_param(hdrfp, 2 ,&bitpix, &naxis, naxes, status); fits_read_key(hdrfp, TLONG, "BZERO", &bzero, NULL, status); /* Check for needed updates */ // Writing new FITS as double if(bitpix != DOUBLE_IMG){ bitpix = DOUBLE_IMG; fits_update_key(fitsfp, TSHORT, "BITPIX", &bitpix, mod_comm, status); } // check for 'zero level' (needed for type long FITS headers) // NOTE: If input header does not contain this keyword (status = 202), // skip update & reset CFITSIO status to zero. if(bzero != 0 || *status != 202){ bzero = 0; fits_update_key(fitsfp, TSHORT, "BZERO", &bzero, mod_comm, status); } *status = 0; // Reset Status // Check new axis lengths are correct if(naxes[0] != write_size[0]) fits_update_key(fitsfp, TULONG,"NAXIS1",&write_size[0],mod_comm,status); if(naxes[1] != write_size[1]) fits_update_key(fitsfp, TULONG,"NAXIS2",&write_size[1],mod_comm,status); /* Write array to file */ fpixel[0] = 1; for(k=0; k < write_size[1]; k++){ // Loop over size[1] rows (i.e. y) fpixel[1] = k + 1; if(fits_write_pix(fitsfp, TDOUBLE, fpixel, write_size[0], array[k], status)){ fits_report_error(stderr,*status); break; } } /* Add/modify keyword for date modified 'DATE-MOD' & 'TIME-MOD' */ time(&now); ptr = localtime(&now); strftime(buf_date, FLEN_VALUE, "%Y-%m-%d", ptr); strftime(buf_time, FLEN_VALUE, "%H:%M:%S", ptr); fits_update_key(fitsfp, TSTRING, "DATE-MOD", buf_date, mod_comm, status); fits_update_key(fitsfp, TSTRING, "TIME-MOD", buf_time, NULL, status); /* Clean up */ fits_close_file(fitsfp, status); fits_close_file(hdrfp, status); /* Report any CFITSIO errors to stderr */ if(!*status) fitswrap_catcherror(status); // Send pointer not value return; }
bool FITSImage::loadFITS ( const QString &inFilename, QProgressDialog *progress ) { int status=0, nulval=0, anynull=0; long fpixel[2], nelements, naxes[2]; char error_status[512]; qDeleteAll(starCenters); starCenters.clear(); if (mode == FITS_NORMAL && progress) { progress->setLabelText(i18n("Please hold while loading FITS file...")); progress->setWindowTitle(i18n("Loading FITS")); } if (mode == FITS_NORMAL && progress) progress->setValue(30); if (fptr) { fits_close_file(fptr, &status); if (tempFile) QFile::remove(filename); } filename = inFilename; if (filename.contains("/tmp/")) tempFile = true; else tempFile = false; filename.remove("file://"); if (fits_open_image(&fptr, filename.toAscii(), READONLY, &status)) { fits_report_error(stderr, status); fits_get_errstatus(status, error_status); if (progress) KMessageBox::error(0, i18n("Could not open file %1 (fits_get_img_param). Error %2", filename, QString::fromUtf8(error_status)), i18n("FITS Open")); return false; } if (mode == FITS_NORMAL && progress) if (progress->wasCanceled()) return false; if (mode == FITS_NORMAL && progress) progress->setValue(40); if (fits_get_img_param(fptr, 2, &(stats.bitpix), &(stats.ndim), naxes, &status)) { fits_report_error(stderr, status); fits_get_errstatus(status, error_status); if (progress) KMessageBox::error(0, i18n("FITS file open error (fits_get_img_param): %1", QString::fromUtf8(error_status)), i18n("FITS Open")); return false; } if (stats.ndim < 2) { if (progress) KMessageBox::error(0, i18n("1D FITS images are not supported in KStars."), i18n("FITS Open")); return false; } if (fits_get_img_type(fptr, &data_type, &status)) { fits_report_error(stderr, status); fits_get_errstatus(status, error_status); if (progress) KMessageBox::error(0, i18n("FITS file open error (fits_get_img_type): %1", QString::fromUtf8(error_status)), i18n("FITS Open")); return false; } if (mode == FITS_NORMAL && progress) if (progress->wasCanceled()) return false; if (mode == FITS_NORMAL && progress) progress->setValue(60); stats.dim[0] = naxes[0]; stats.dim[1] = naxes[1]; delete (image_buffer); image_buffer = NULL; image_buffer = new float[stats.dim[0] * stats.dim[1]]; if (image_buffer == NULL) { qDebug() << "Not enough memory for image_buffer"; return false; } if (mode == FITS_NORMAL && progress) { if (progress->wasCanceled()) { delete (image_buffer); return false; } } if (mode == FITS_NORMAL && progress) progress->setValue(70); nelements = stats.dim[0] * stats.dim[1]; fpixel[0] = 1; fpixel[1] = 1; qApp->processEvents(); if (fits_read_2d_flt(fptr, 0, nulval, naxes[0], naxes[0], naxes[1], image_buffer, &anynull, &status)) { fprintf(stderr, "fits_read_pix error\n"); fits_report_error(stderr, status); return false; } if (mode == FITS_NORMAL && progress) { if (progress->wasCanceled()) { delete (image_buffer); return false; } } calculateStats(); if (mode == FITS_NORMAL && progress) progress->setValue(80); //currentWidth = stats.dim[0]; // currentHeight = stats.dim[1]; qApp->processEvents(); if (mode == FITS_NORMAL) { checkWCS(); if (progress) progress->setValue(90); } if (mode == FITS_NORMAL && progress) { if (progress->wasCanceled()) { delete (image_buffer); return false; } } if (mode == FITS_NORMAL && progress) progress->setValue(100); starsSearched = false; return true; }
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); }
int read_kpvt( char *input_file_name, char *aux_file, int verbose_flag, int minmax_flag) { int status = 0; /* * If the Compiler macro FITS is not defined, that means the makefile * determined that libcfitsio.a was not available. Instead of shutting down * the entire converter Lets just disable any read routines thatt depend on * the FITS library * */ #ifdef FITS extern int linear_minmax_search(float *, int, float *, float *); fitsfile *fits_filePtr; char header_buffer[FLEN_CARD ]; float operand1; int i, j; int number_of_fits_header_keys; int number_of_fits_hdus; int hdu_type; int bit_pix; long naxes[10]; int maxdim = 10; long fpixel[10]; float missing_val = 256*256*256; int anynul; float net_flux_2d_static[180][360]; float net_flux_2d_static_flat[64800]; float total_flux_2d_static[180][360]; float total_flux_2d_static_flat[64800]; float weights_2d_static[180][360]; float weights_2d_static_flat[64800]; /** open fits file **/ fits_open_file( &fits_filePtr, input_file_name, READONLY, &status); /** get number_of_fits_header_keys **/ fits_get_hdrspace(fits_filePtr, &number_of_fits_header_keys, NULL, &status); /** get the number of hdu's in the current file **/ fits_get_num_hdus(fits_filePtr, &number_of_fits_hdus, &status); printf("FITS File: %s has %d hdu's\n", input_file_name, number_of_fits_hdus); /** for every hdu **/ for (i=0; i<number_of_fits_hdus; i++) { /** select hdu by number **/ fits_movabs_hdu(fits_filePtr, number_of_fits_hdus, &hdu_type, &status); /** there are three type of hdu's * IMAGE_HDU * ACSII_TBL * BINARY_TBL * ********************************/ if (hdu_type == IMAGE_HDU) { printf("Current HDU Type is IMAGE\n"); /*** get general info about the current image file ***/ fits_get_img_param( fits_filePtr, maxdim, &bit_pix, &naxis, naxes, &status); printf("bitpix = %d\nnaxis = %d\n", bit_pix, naxis); if (DEBUG_FLAG) { for (i = 0; i<naxis; i++) printf("naxis[%d] = %ld\n", i, naxes[i]); } naxis1 = naxes[0]; naxis2 = naxes[1]; number_of_elements = naxis1 * naxis2; /** dynamically allocate space for the image grid **/ carrington_longitiude = malloc(naxis1 * sizeof(float)); carrington_sine_latitude = malloc(naxis2 * sizeof(float)); /** dynamically allocate space for the flat variable arrays **/ net_flux = malloc(number_of_elements * sizeof(float)); total_flux = malloc(number_of_elements * sizeof(float)); weights = malloc(number_of_elements * sizeof(float)); /** manually insert sequential grid values from 1 - naxes[*] **/ operand1 = 2.0 / naxis2; if (DEBUG_FLAG) { printf( "\n\n\n\n\n\nWTF: operand1 = %f\nnaxis2 = %d\n", operand1, naxis2); } for (i=0; i < naxis2; i++) { /** convert to sine latidude **/ /* carrington_sine_latitude[i] = i+1; */ carrington_sine_latitude[i] = (-1.0) + (operand1 * ( (i + 1 ) - .5 ) ); if (DEBUG_FLAG) printf("%d deg = %f\n", i+1, carrington_sine_latitude[i]); } for (i=0; i < naxis1; i++) { carrington_longitiude[i] = i+1; if (DEBUG_FLAG) printf("%d deg = %f deg\n", i+1, carrington_longitiude[i]); } /** print position values **/ for (i=0; i<naxis2; i+=30) { for (j=0; j<naxis1; j+=30) { if (DEBUG_FLAG) { printf( "position[%f][%f]\n", carrington_sine_latitude[i], carrington_longitiude[j]); } } } /** print c_lon values **/ for (i=0; i<naxis1; i++) { if( DEBUG_FLAG ) printf("c_lon[%d] = %f ", i, carrington_longitiude[i]); } /** print c_sine_lat values **/ for (i=0; i<naxis2; i++) { if( DEBUG_FLAG ) printf("c_sine_lat[%d] = %f ", i, carrington_sine_latitude[i]); } /** dynamically allocate memory for the three image slices that we * expect - we must reverse the majority since the fits api expects * array[column][row] **/ net_flux_2d = malloc(naxis1 * sizeof(float *)); for (i=0; i< naxis1; i++) { net_flux_2d[i] = malloc(naxis2 * sizeof(float)); } total_flux_2d = malloc(naxis2 * sizeof(float *)); for (i=0; i< naxis2; i++) { total_flux_2d[i] = malloc(naxis1 * sizeof(float)); } weights_2d = malloc(naxis2 * sizeof(float *)); for (i=0; i< naxis2; i++) { weights_2d[i] = malloc(naxis1 * sizeof(float)); } /*** read in the image data ***/ /** this is the starting point for the read - slice one - net flux **/ fpixel[0] = fpixel[1] = fpixel[2]= 1; if( DEBUG_FLAG ) printf( "\nfpixel[0] = %ld\nfpixel[1] = %ld\nfpixel[2] = %ld\nnumber_of_elements = %ld\n\n", fpixel[0], fpixel[1], fpixel[2], number_of_elements); /* fits_read_pix( fits_filePtr, TFLOAT, fpixel, number_of_elements, &missing_val, *net_flux_2d, &anynul, &status ); */ fits_read_pix( fits_filePtr, TFLOAT, fpixel, number_of_elements, &missing_val, net_flux_2d_static, &anynul, &status); /** this is the starting point for the read - slice two - total flux */ fpixel[2] = 2; if( DEBUG_FLAG ) printf( "fpixel[0] = %ld\nfpixel[1] = %ld\nfpixel[2] = %ld\nnumber_of_elements = %ld\n\n", fpixel[0], fpixel[1], fpixel[2], number_of_elements); /* * fits_read_pix( fits_filePtr, TFLOAT, fpixel, number_of_elements, * &missing_val, *total_flux_2d, &anynul, &status ); * */ fits_read_pix( fits_filePtr, TFLOAT, fpixel, number_of_elements, &missing_val, total_flux_2d_static, &anynul, &status); /** this is the starting point for the read - slice three - weights **/ fpixel[2] = 3; if( DEBUG_FLAG )printf( "fpixel[0] = %ld\nfpixel[1] = %ld\nfpixel[2] = %ld\nnumber_of_elements = %ld\n\n", fpixel[0], fpixel[1], fpixel[2], number_of_elements); /* * fits_read_pix( fits_filePtr, TFLOAT, fpixel, number_of_elements, * &missing_val, *weights_2d, &anynul, &status ); * */ fits_read_pix( fits_filePtr, TFLOAT, fpixel, number_of_elements, &missing_val, weights_2d_static, &anynul, &status); /** flatten out arrays **/ for (i=0; i<naxis2; i++) { for (j=0; j<naxis1; j++) { /* net_flux[ i * naxis1 + j] = net_flux_2d_static[i][j]; total_flux[ i * naxis1 + j] = total_flux_2d[i][j]; weights[ i * naxis1 + j] = weights_2d[i][j]; */ net_flux[ i * naxis1 + j] = net_flux_2d_static[i][j]; total_flux[ i * naxis1 + j] = total_flux_2d_static[i][j]; weights[ i * naxis1 + j] = weights_2d_static[i][j]; } } /*** DEBUG PRINT OUT OF VALUES ***/ /* for( i=0;i<naxis2;i+=20) { for( j=0;j<naxis1;j+=20) { printf( "net_flux[%d][%d] = %f\n", i,j, net_flux[i * naxis1 + j] ); printf( "net_flux_2d[%d][%d] = %f\n", i,j, net_flux_2d[i][j] ); printf( "net_flux_2d_static[%d][%d] = %f\n", i,j, net_flux_2d_static[i][j] ); printf( "net_flux_2d_static_flat[%d][%d] = %f\n", i,j, net_flux_2d_static_flat[i * naxis1 + j] ); printf( "total_flux[%d][%d] = %f\n", i,j, total_flux[i * naxis1 + j] ); printf( "total_flux_2d[%d][%d] = %f\n", i,j, total_flux_2d[i][j] ); printf( "weights[%d][%d] = %f\n", i,j, weights[i * naxis1 + j] ); printf( "weights_2d[%d][%d] = %f\n\n", i,j, weights_2d[i][j] ); } } */ } else if (hdu_type == ASCII_TBL) { printf("Current HDU Type is ACSII TABLE\n"); } else if (hdu_type == BINARY_TBL) { printf("Current HDU Type is BINARY TABLE\n"); } /*** get the header info for the current hdu ***/ for (i = 0; i < number_of_fits_header_keys; i++) { fits_read_record(fits_filePtr, i, header_buffer, &status); printf("%s\n", header_buffer); } } /** close fits file **/ fits_close_file(fits_filePtr, &status); if (status) { fits_report_error( stderr, status); } /* * calcluate actual min/max values for each ariable unless -nominmax flag was * specified * */ /** add more error handling for each linear_minmax_search function call **/ /*** if -nominmax option was NOT specified ***/ if ( !minmax_flag) { if (verbose_flag) { printf("\ncalculating actual minimum & maximum values for each variable ...\n"); } if (verbose_flag) { printf("%-25s%-25s%-25s\n", "", "min", "max"); } linear_minmax_search( carrington_longitiude, naxis1, &carrington_longitiude_actual_min, &carrington_longitiude_actual_max); if (verbose_flag) { printf( "%-25s%-25g%-25g\n", "c_lon", carrington_longitiude_actual_min, carrington_longitiude_actual_max); } linear_minmax_search( carrington_sine_latitude, naxis2, &carrington_sine_latitude_actual_min, &carrington_sine_latitude_actual_max); if (verbose_flag) { printf( "%-25s%-25g%-25g\n", "c_sine_lat", carrington_sine_latitude_actual_min, carrington_sine_latitude_actual_max); } linear_minmax_search( net_flux, number_of_elements, &net_flux_actual_min, &net_flux_actual_max); if (verbose_flag) { printf( "%-25s%-25g%-25g\n", "net_flux", net_flux_actual_min, net_flux_actual_max); } linear_minmax_search( total_flux, number_of_elements, &total_flux_actual_min, &total_flux_actual_max); if (verbose_flag) { printf( "%-25s%-25g%-25g\n", "total_flux", total_flux_actual_min, total_flux_actual_max); } linear_minmax_search( weights, number_of_elements, &weights_actual_min, &weights_actual_max); if (verbose_flag) { printf( "%-25s%-25g%-25g\n", "weights", weights_actual_min, weights_actual_max); } } #endif #ifndef FITS printf("\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printf("!! WARNING: from %s line [%d]. Conversion Software was not compiled and linked with netCDF libraries ( libcfitsio.a ). No .fts FITS files will be ingested... \n", __FILE__, __LINE__ ); return EXIT_FAILURE; #endif return status; }
void read_fits(const char* filename, int datatype, size_t* width, size_t* height, void** image) { int status = 0; // the FITS file fitsfile* fptr; // metadata int bitpix; int naxis; long naxes[2]; // total number of pixels long npix; // reading offset long fpixel[2] = { 1, 1 }; // size of output image pixels size_t spix = 0; // open FITS file fits_open_image(&fptr, filename, READONLY, &status); if(status) fits_error(filename, status); // get metadata fits_get_img_param(fptr, 2, &bitpix, &naxis, naxes, &status); if(status) fits_error(filename, status); // check dimension of image if(naxis != 2) errorf(filename, 0, "file has %d axes (should be 2)", naxis); // set dimensions *width = naxes[0]; *height = naxes[1]; // size of output pixels switch(datatype) { case TINT: spix = sizeof(int); break; case TFLOAT: spix = sizeof(float); break; case TDOUBLE: spix = sizeof(double); break; default: error("read_fits(): datatype %d not implemented", datatype); } // create array for pixels npix = naxes[0]*naxes[1]; *image = malloc(npix*spix); if(!*image) errori(NULL); // read pixels into array fits_read_pix(fptr, datatype, fpixel, npix, NULL, *image, NULL, &status); if(status) fits_error(filename, status); // close file again fits_close_file(fptr, &status); if(status) fits_error(filename, status); }
int main(int argc, char *argv[]) { fitsfile *fptr = 0; /* FITS file pointer, defined in fitsio.h */ int status = 0; /* CFITSIO status value MUST be initialized to zero! */ int bitpix = 0, naxis = 0, ii = 0, d = 0; long naxes[9] = {1,1,1,1,1,1,1,1,1}, fpixel[9] = {1,1,1,1,1,1,1,1,1}; double *pixels = 0; char format[20], hdformat[20]; int printhelp = (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)); if (printhelp || argc != 2) { fprintf(stderr, "Usage: %s filename[ext][section filter] \n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, "List the the pixel values in a FITS array \n"); fprintf(stderr, "\n"); fprintf(stderr, "Example: \n"); fprintf(stderr, " %s array.fits - list the whole array\n", argv[0]); fprintf(stderr, " %s array.fits[100:110,400:410] - list a section\n", argv[0]); fprintf(stderr, " %s table.fits[2][bin (x,y) = 32] - list the pixels in\n", argv[0]); fprintf(stderr, " an array constructed from a 2D histogram of X and Y\n"); fprintf(stderr, " columns in a table with a binning factor = 32\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)) { if (!fits_get_img_param(fptr, 9, &bitpix, &naxis, naxes, &status)) { if (naxis > 9 || naxis == 0) { fprintf(stderr, "Error: only 1- to 9-dimensional arrays are supported\n"); } else { /* get memory for 1 row */ pixels = (double *) malloc(naxes[0] * sizeof(double)); if (pixels == NULL) { fprintf(stderr, "Memory allocation error\n"); return (1); } if (bitpix > 0) { /* set the default output format string */ strcpy(hdformat, " %7d"); strcpy(format, " %7.0g"); } else { strcpy(hdformat, " %15d"); strcpy(format, " %15.5g"); } if (naxis > 2) { /* label higher dimensions */ fprintf(fout, "#"); for (d = naxis - 1; d > 0; d--) { fprintf(fout, "%1iD ", d+1); } fprintf(fout, "\n"); } /* loop over all the rows in the array */ for (fpixel[8] = 1; fpixel[8] <= naxes[8]; fpixel[8]++) { for (fpixel[7] = 1; fpixel[7] <= naxes[7]; fpixel[7]++) { for (fpixel[6] = 1; fpixel[6] <= naxes[6]; fpixel[6]++) { for (fpixel[5] = 1; fpixel[5] <= naxes[5]; fpixel[5]++) { for (fpixel[4] = 1; fpixel[4] <= naxes[4]; fpixel[4]++) { for (fpixel[3] = 1; fpixel[3] <= naxes[3]; fpixel[3]++) { for (fpixel[2] = 1; fpixel[2] <= naxes[2]; fpixel[2]++) { for (fpixel[1] = 1; fpixel[1] <= naxes[1]; fpixel[1]++) { if (fits_read_pix(fptr, TDOUBLE, fpixel, naxes[0], NULL, pixels, NULL, &status)) { /* read row of pixels */ break; /* jump out of loop on error */ } if (naxis > 2) { /* print higher dimensions */ fprintf(fout, " "); for (d = naxis - 1; d > 0; d--) { fprintf(fout, "% 2li ", fpixel[d]); } } for (ii = 0; ii < naxes[0]; ii++) { fprintf(fout, format, pixels[ii]); /* print each value */ } fprintf(fout, "\n"); /* terminate line */ } } } } } } } } free(pixels); } } fits_close_file(fptr, &status); } pclose(fout); if (status) { fits_report_error(stderr, status); /* print any error message */ } return (status); }