Java BasicHDU类代码示例

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
public void readFits(String fitsUrl) throws IOException, FitsException {
        URL fetchUrl = new URL(fitsUrl);
        String[] fileName = fitsUrl.split("/");
        try (InputStream is = PluginUtils.copyUrlOpenStream(fetchUrl, "PTF-" + fileName[fileName.length - 1], 3)) {
            Fits fits = new Fits(is);
            for (BasicHDU<?> basicHDU : fits.read()) {
                System.out.println(basicHDU);
            }
            ImageHDU image = (ImageHDU) fits.getHDU(1);

//            float[] mags = (float[]) table.getColumn("MAG_V");
//            float[] errs = (float[]) table.getColumn("ERRMAG_V");
//            double[] barytimes = (double[]) table.getColumn("BARYTIME");
//            double[] telapses = (double[]) table.getColumn("TELAPSE");
//
//            for (int i = 0; i < mags.length; i++) {
//                double jd = barytimes[i] + 2451544.5 + telapses[i] / 2 / 86400;
//                System.out.println(jd + "," + mags[i] + "," + errs[i]);
//            }
        }
    }
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
protected void read(Fits fits, boolean readFully) throws Exception {
	// Read in entire FITS file
	BasicHDU<?>[] HDU = fits.read();

	parseScanPrimaryHDU(HDU[0]);
	instrument.parseScanPrimaryHDU(HDU[0]);
	instrument.parseHardwareHDU((BinaryTableHDU) HDU[1]);
	instrument.validate(this);	
	clear();

	Mustang2Integration integration = getIntegrationInstance();
	integration.read((BinaryTableHDU) HDU[2]);
	add(integration);
	
	try { fits.getStream().close(); }
	catch(IOException e) {}
	
	instrument.samplingInterval = integration.instrument.samplingInterval;
	instrument.integrationTime = integration.instrument.integrationTime;
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
public void readImage(Fits fits) throws Exception {
	image = new Data2D();
	
	int N = fits.getNumberOfHDUs();
	if(N == 1) {
		image.read(fits);
		return;
	}
	
	try {
		int n = Integer.parseInt(type);
		image.read(fits, n);
	}
	catch(NumberFormatException e) {
		for(BasicHDU hdu : fits.read()) {
			String extName = hdu.getHeader().getStringValue("EXTNAME");
			if(extName != null) if(extName.equalsIgnoreCase(type)) {
				image.read(hdu);
				return;
			}
		}
	}
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
public static void main(String args[]) 
   throws FitsException, IOException
   {
if (args.length != 3)
    usage();
//String out_name = "decimate_out.fits";
String in_name = args[0];
String out_name = args[1];
int decimate_factor = Integer.valueOf(args[2]);

Decimate decimate = new Decimate();

Fits f = new Fits(args[0]);
BasicHDU basic_hdu = f.getHDU(0);
System.out.println("decimate.isDecimateable  = " + decimate.isDecimateable(f, basic_hdu));

//f = new Fits(args[0]);
Fits out_fits = decimate.do_decimate(f, basic_hdu, decimate_factor);
FileOutputStream fo = new java.io.FileOutputStream(out_name);
BufferedDataOutputStream o = new BufferedDataOutputStream(fo);
out_fits.write(o);
   }
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
private short[] getMasksInFits(Fits fits) throws FitsException {

        //get all the Header Data Unit from the fits file
        BasicHDU[] HDUs = fits.read();

        for (int j = 0; j < HDUs.length; j++) {
            if (!(HDUs[j] instanceof ImageHDU)) {
                continue;   //ignor non-image extensions
            }
            Header header =  HDUs[j].getHeader();
            if (header == null) {
                throw new FitsException("Missing header in FITS file");
            }
             else  if ( header.containsKey("EXTTYPE")  &&  header.getStringValue("EXTTYPE").equalsIgnoreCase("mask") ){
                short[] mArray=(short[]) ArrayFuncs.flatten(ArrayFuncs.convertArray(HDUs[j].getData().getData(), Short.TYPE, true));
                return getMasks(header, mArray);
           }
        }
        return null;


     }
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
/**
 * This method is used by FitsImageCube only
 * @param fits
 * @param hdu
 * @return
 * @throws FitsException
 */
public static FitsRead[] createFitsReadArray(Fits fits, BasicHDU hdu)
        throws FitsException {


    if (hdu == null || hdu.getData().getSize()==0) {
        // Error: file doesn't seem to have any HDUs!
        return null;
    }

    BasicHDU[] HDUs={hdu};
    ArrayList<BasicHDU> HDUList = getHDUList(HDUs);

    if (HDUList.size() == 0)
        throw new FitsException("No image headers in FITS file");

    FitsRead[] fitsReadAry = new FitsRead[HDUList.size()];
    for (int i = 0; i < HDUList.size(); i++) {
        fitsReadAry[i] = new FitsRead(fits, (ImageHDU) HDUList.get(i));
        fitsReadAry[i].indexInFile = i;
    }

    return fitsReadAry;
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
private static BasicHDU[] splitFitsCube(ImageHDU hdu)
        throws FitsException {

    Header header = hdu.getHeader();
    int bitpix = header.getIntValue("BITPIX", -1);

    if (!SUPPORTED_BIT_PIXS.contains(new Integer(bitpix))) {
        System.out.println("Unimplemented bitpix = " + bitpix);
    }


    int naxis3 = header.getIntValue("NAXIS3", 0);
    float[][][] data32 = (float[][][]) ArrayFuncs.convertArray(hdu.getData().getData(), Float.TYPE, true);

    BasicHDU[] hduList = new BasicHDU[naxis3];
    for (int i = 0; i < naxis3; i++) {
        hduList[i] = makeHDU(hdu,data32[i] );
        hdu.addValue("SPOT_PL", i + 1, "PLANE OF FITS CUBE (IN SPOT)");
        hdu.getHeader().resetOriginalSize();
     }

    return hduList;
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
@Override
public void addIntegrationsFrom(BasicHDU<?>[] HDU) throws Exception {
    ArrayList<BinaryTableHDU> dataHDUs = new ArrayList<BinaryTableHDU>();

    for(int i=1; i<HDU.length; i++) if(HDU[i] instanceof BinaryTableHDU) {
        Header header = HDU[i].getHeader();
        String extName = header.getStringValue("EXTNAME");
        if(extName.equalsIgnoreCase("Timestream")) dataHDUs.add((BinaryTableHDU) HDU[i]);
    }

    HawcPlusIntegration integration = this.getIntegrationInstance();
    integration.read(dataHDUs);
    add(integration);

}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
@Override
protected PfssData backgroundWork() {
    try (NetClient nc = NetClient.of(url); Fits fits = new Fits(nc.getStream())) {
        BasicHDU<?> hdus[] = fits.read();
        if (hdus == null || hdus.length < 2 || !(hdus[1] instanceof BinaryTableHDU))
            throw new Exception("Could not read FITS: " + url);

        BinaryTableHDU bhdu = (BinaryTableHDU) hdus[1];
        Header header = bhdu.getHeader();

        String dateFits = header.getStringValue("DATE-OBS");
        if (dateFits == null)
            throw new Exception("DATE-OBS not found: " + url);
        JHVDate date = new JHVDate(dateFits);
        if (time != date.milli)
            throw new Exception("Inconsistent DATE-OBS. Expected " + new JHVDate(time) + ", got " + date + ": " + url);

        int points = header.getIntValue("HIERARCH.POINTS_PER_LINE");
        if (points == 0)
            throw new Exception("POINTS_PER_LINE not found: " + url);

        short[] flinex = (short[]) bhdu.getColumn("FIELDLINEx");
        short[] fliney = (short[]) bhdu.getColumn("FIELDLINEy");
        short[] flinez = (short[]) bhdu.getColumn("FIELDLINEz");
        short[] flines = (short[]) bhdu.getColumn("FIELDLINEs");
        if (flinex.length != fliney.length || flinex.length != flinez.length || flinex.length != flines.length)
            throw new Exception("Fieldline arrays not equal " + flinex.length + " " + fliney.length + " " + flinez.length + " " + flinex.length + ": " + url);

        return new PfssData(date, flinex, fliney, flinez, flines, points);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
public static Fits do_crop(Fits inFits, int min_x, int min_y, int max_x, int max_y)
        throws FitsException
{
    if (SUTDebug.isDebug())
    {
        System.out.println("RBH do_crop  min_x = " + min_x +
                "  min_y = " + min_y + "  max_x = " + max_x + "  max_y = " + max_y);
    }
    BasicHDU out_HDU = null;
    Fits ret_fits = new Fits();
    BasicHDU[] myHDUs = inFits.read();
    out_HDU = split_FITS_cube(myHDUs[0], min_x, min_y, max_x, max_y);
    ret_fits.addHDU(out_HDU);
    return(ret_fits);
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
static public boolean isCropable(Fits fits)
   {
BasicHDU hdus[];
try
{
    hdus = fits.read();
}
catch (FitsException fe)
{
    return(false);
}
if (hdus.length > 1)
{
    return (false);
}
Header header = hdus[0].getHeader();
int naxis = header.getIntValue("NAXIS");
if (naxis < 3)
{
    return (true);
}
int naxis3 = header.getIntValue("NAXIS3");
if (naxis3 > 1)
{
    return (false);
}
else
{
    return (true);
}
   }
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
public static Header getFirstHeader(File f) throws FitsException {
       BasicHDU myHDU = null;
Header header;

       Fits myFits = new Fits(f);
try
{
    //myHDUs = myFits.read();
    myHDU = myFits.readHDU();
}
catch (FitsException fe)
{
    throw fe;
    //System.out.println("RBH caught FitsException");
    //fe.printStackTrace();
}
catch (IOException ioe)
{
    throw new FitsException(ioe.getMessage());
    //System.out.println("RBH caught IOException");
    //ioe.printStackTrace();
}
if (myHDU == null)
    throw new FitsException("cannot read header");
header = myHDU.getHeader();
return header;
   }
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
public static void writeFitsFile(OutputStream stream, FitsRead[] fitsReadAry, Fits refFits) throws FitsException, IOException{
    Fits output_fits = new Fits();
    for(FitsRead fr : fitsReadAry) {
        BasicHDU one_image_hdu = refFits.getHDU(0);
        Header header = one_image_hdu.getHeader();
        //Data data = one_image_hdu.getData();
        //ImageHDU image_hdu = new ImageHDU(header, data);

        ImageHDU imageHDU = new ImageHDU(header,  fr.getImageData(header, fr.float1d));
        output_fits.addHDU(imageHDU);
    }
    output_fits.write(new DataOutputStream(stream));
}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
/**
 * Test the FitsImaegCube
 * @param args
 * @throws FitsException
 * @throws IOException
 */
public static void main(String[] args) throws FitsException, IOException {
    if (args.length != 2) {
        usage();
    }

    String inFitsName = args[0];
    String outFitsName = args[1];
    Fits fits = new Fits(inFitsName);

    FitsImageCube fic = FitsRead.createFitsImageCube(fits);
    Object[] keys = fic.getMapKeys();
     FitsRead fitsRead0 = fic.getFitsReadMap().get(keys[0])[1];
    FileOutputStream fo = new java.io.FileOutputStream(outFitsName+"fitsRead1ReadAsImageCube.fits");
    fitsRead0.writeSimpleFitsFile(fo);
    fo.close();

    FitsRead[] fry = FitsRead.createFitsReadArray(fits);
    fo  = new java.io.FileOutputStream(outFitsName+"fitsRead1ReadAsFitsRead.fits");//"f-32AsFitsRead.fits");//
    fry[1].writeSimpleFitsFile(fo);
    fo.close();

    Fits newFits = new Fits(outFitsName+"fitsRead1ReadAsFitsRead.fits");
    BasicHDU[] hdus = newFits.read();


}
 

import nom.tam.fits.BasicHDU; //导入依赖的package包/类
private void open_ref(Fits refFits) throws FitsException
{
    try
    {

	    BasicHDU HDU = refFits.getHDU(0);
	    ref_fits_header = HDU.getHeader();
	    //BufferedDataInputStream ibs = refFits.getStream();
	    //ref_fits_header = Header.readHeader(ibs);
	    if (ref_fits_header == null) 
	    {
		if (SUTDebug.isDebug())
		{
		    System.out.println("HDU null! (ref image)");
		}
		throw new FitsException("HDU null! (ref image)");
	    }

	    ref_header = new ImageHeader(ref_fits_header);
    }
    catch (IOException e)
    {
	if (SUTDebug.isDebug())
	{
	    System.out.println("got IOException: " + e.getMessage());
	}
	throw new FitsException("got IOException: " + e.getMessage());
    }
    open_ref();
}