def wcsalign(hdu_in, header, outname=None, clobber=False): """ Align one FITS image to a specified header Requires pyast. Parameters ---------- hdu_in : `~astropy.io.fits.PrimaryHDU` The HDU to reproject (must have header & data) header : `~astropy.io.fits.Header` The target header to project to outname : str (optional) The filename to write to. clobber : bool Overwrite the file ``outname`` if it exists Returns ------- The reprojected fits.PrimaryHDU Credits ------- Written by David Berry and adapted to functional form by Adam Ginsburg ([email protected]) """ try: import starlink.Ast as Ast import starlink.Atl as Atl except ImportError: raise ImportError("starlink could not be imported, wcsalign is not " "available") # Create objects that will transfer FITS header cards between an AST # FitsChan and the fits header describing the primary HDU of the # supplied FITS file. adapter_in = Atl.PyFITSAdapter(hdu_in) hdu_ref = pyfits.PrimaryHDU(header=header) adapter_ref = Atl.PyFITSAdapter(hdu_ref) # Create a FitsChan for each and use the above adapters to copy all the # header cards into it. fitschan_in = Ast.FitsChan(adapter_in, adapter_in) fitschan_ref = Ast.FitsChan(adapter_ref, adapter_ref) # Get the flavour of FITS-WCS used by the header cards currently in the # input FITS file. This is so that we can use the same flavour when we # write out the modified WCS. encoding = fitschan_in.Encoding # Read WCS information from the two FitsChans. Additionally, this removes # all WCS information from each FitsChan. The returned wcsinfo object # is an AST FrameSet, in which the current Frame describes WCS coordinates # and the base Frame describes pixel coodineates. The FrameSet includes a # Mapping that specifies the transformation between the two Frames. wcsinfo_in = fitschan_in.read() wcsinfo_ref = fitschan_ref.read() # Check that the input FITS header contained WCS in a form that can be # understood by AST. if wcsinfo_in is None: raise ValueError( "Failed to read WCS information from {0}".format(hdu_in)) # This is restricted to 2D arrays, so check theinput FITS file has 2 # pixel axes (given by Nin) and 2 WCS axes (given by Nout). elif wcsinfo_in.Nin != 2 or wcsinfo_in.Nout != 2: raise ValueError("{0} is not 2-dimensional".format(hdu_in)) # Check the reference FITS file in the same way. elif wcsinfo_ref is None: raise ValueError( "Failed to read WCS information from {0}".format(hdu_ref)) elif wcsinfo_ref.Nin != 2 or wcsinfo_ref.Nout != 2: raise ValueError("{0} is not 2-dimensional".format(hdu_ref)) # Proceed if the WCS information was read OK. # Attempt to get a mapping from pixel coords in the input FITS file to # pixel coords in the reference fits file, with alignment occuring by # preference in the current WCS frame. Since the pixel coordinate frame # will be the base frame in each Frameset, we first invert the # FrameSets. This is because the Convert method aligns current Frames, # not base frames. wcsinfo_in.invert() wcsinfo_ref.invert() alignment_fs = wcsinfo_in.convert(wcsinfo_ref) # Invert them again to put them back to their original state (i.e. # base frame = pixel coords, and current Frame = WCS coords). wcsinfo_in.invert() wcsinfo_ref.invert() # Check alignment was possible. if alignment_fs is None: raise Exception("Cannot find a common coordinate system shared by " "{0} and {1}".format(hdu_in, hdu_ref)) else: # Get the lower and upper bounds of the input image in pixel # indices. All FITS arrays by definition have lower pixel bounds of # [1, 1] (unlike NDFs). Note, unlike fits AST uses FITS ordering for # storing pixel axis values in an array (i.e. NAXIS1 first, NAXIS2 # second, etc). lbnd_in = [1, 1] ubnd_in = [fitschan_in["NAXIS1"], fitschan_in["NAXIS2"]] # Find the pixel bounds of the input image within the pixel coordinate # system of the reference fits file. (lb1, ub1, xl, xu) = alignment_fs.mapbox(lbnd_in, ubnd_in, 1) (lb2, ub2, xl, xu) = alignment_fs.mapbox(lbnd_in, ubnd_in, 2) # Calculate the bounds of the output image. lbnd_out = [int(lb1), int(lb2)] ubnd_out = [int(ub1), int(ub2)] # Unlike NDFs, FITS images cannot have an arbitrary pixel origin so # we need to ensure that the bottom left corner of the input image # gets mapped to pixel [1,1] in the output. To do this we, extract the # mapping from the alignment FrameSet and add on a ShiftMap (a mapping # that just applies a shift to each axis). shift = [1 - lbnd_out[0], 1 - lbnd_out[1]] alignment_mapping = alignment_fs.getmapping() shiftmap = Ast.ShiftMap(shift) total_map = Ast.CmpMap(alignment_mapping, shiftmap) # Modify the pixel bounds of the output image to take account of this # shift of origin. lbnd_out[0] += shift[0] lbnd_out[1] += shift[1] ubnd_out[0] += shift[0] ubnd_out[1] += shift[1] # Get the value used to represent missing pixel values if "BLANK" in fitschan_in: badval = fitschan_in["BLANK"] flags = Ast.USEBAD else: badval = 0 flags = 0 # Resample the data array using the above mapping. # total_map was pixmap; is this right? (npix, out, out_var) = total_map.resample(lbnd_in, ubnd_in, hdu_in.data, None, Ast.LINEAR, None, flags, 0.05, 1000, badval, lbnd_out, ubnd_out, lbnd_out, ubnd_out) # Store the aligned data in the primary HDU, and update the NAXISi # keywords to hold the number of pixels along each edge of the # rotated image. hdu_in.data = out fitschan_in["NAXIS1"] = ubnd_out[0] - lbnd_out[0] + 1 fitschan_in["NAXIS2"] = ubnd_out[1] - lbnd_out[1] + 1 # The WCS to store in the output is the same as the reference WCS # except for the extra shift of origin. So use the above shiftmap to # remap the pixel coordinate frame in the reference WCS FrameSet. We # can then use this FrameSet as the output FrameSet. wcsinfo_ref.remapframe(Ast.BASE, shiftmap) # Attempt to write the modified WCS information to the primary HDU (i.e. # convert the FrameSet to a set of FITS header cards stored in the # FITS file). Indicate that we want to use original flavour of FITS-WCS. fitschan_in.Encoding = encoding fitschan_in.clear('Card') if fitschan_in.write(wcsinfo_ref) == 0: raise Exception("Failed to convert the aligned WCS to Fits-WCS") # If successful, force the FitsChan to copy its contents into the # fits header, then write the changed data and header to the output # FITS file. else: fitschan_in.writefits() if outname is not None: hdu_in.writeto(outname, clobber=clobber) return hdu_in
# Construct a MatrixMap that rotates by the required angle, converted to radians. sinang = math.sin( angle ) cosang = math.cos( angle ) pixmap = Ast.MatrixMap( [ [cosang,sinang], [-sinang,cosang] ] ) # If supplied, get the centre of rotation. if len(sys.argv) > 5: x0 = float( sys.argv[4] ) y0 = float( sys.argv[5] ) # Create aShiftMap to shift the origin and combine it with the # MatrixMap, to give the desired centre of rotation (shift, # rotate, then shift back again). shiftmap = Ast.ShiftMap( [ -x0, -y0 ] ) pixmap = Ast.CmpMap( shiftmap, pixmap ); shiftmap.invert() pixmap = Ast.CmpMap( pixmap, shiftmap ); # The dimensions of the output array are the same as the input array. lbnd_out = lbnd_in ubnd_out = ubnd_in # If no centre of rotation was specified, we use the MatrixMap # unchanged, and determine the bounds of the smallest output image that # will hold the entire rotated input image. These are with respect to # the pixel coordinates of the input array, and so some corners may have # negative pixel coordinates. else: ( lb1, ub1, xl, xu ) = pixmap.mapbox( lbnd_in, ubnd_in, 1 ) ( lb2, ub2, xl, xu ) = pixmap.mapbox( lbnd_in, ubnd_in, 2 )
def rotate(infile, outfile, angle, xcen=None, ycen=None): # Open the FITS file using pyfits. A list of the HDUs in the FITS file is # returned. hdu_list = pyfits.open(infile) # Create an object that will transfer FITS header cards between an AST # FitsChan and the PyFITS header describing the primary HDU of the # supplied FITS file. adapter = Atl.PyFITSAdapter(hdu_list[0]) # Create a FitsChan and use the above adapter to copy all the header # cards into it. fitschan = Ast.FitsChan(adapter, adapter) # Get the flavour of FITS-WCS used by the header cards currently in the # FitsChan. This is so that we can use the same flavour when we write # out the modified WCS. encoding = fitschan.Encoding # Read WCS information from the FitsChan. Additionally, this removes all # WCS information from the FitsChan. The returned wcsinfo object # is an AST FrameSet, in which the current Frame describes WCS coordinates # and the base Frame describes pixel coodineates. The FrameSet includes a # Mapping that specifies the transformation between the two Frames. wcsinfo = fitschan.read() # Check that the FITS header contained WCS in a form that can be # understood by AST. if wcsinfo == None: print("Failed to read WCS information from {0}".format(infile)) # Rotation is restricted to 2D arrays, so check the FITS file has 2 pixel # axes (given by Nin) and 2 WCS axes (given by Nout). elif wcsinfo.Nin != 2 or wcsinfo.Nout != 2: print("{0} is not 2-dimensional".format(infile)) # Proceed if the WCS information was read OK. else: # Get the lower and upper bounds of the input image in pixel indices. # All FITS arrays by definition have lower pixel bounds of [1,1] (unlike # NDFs). Note, unlike pyfits AST uses FITS ordering for storing pixel axis # values in an array (i.e. NAXIS1 first, NAXIS2 second, etc). lbnd_in = [1, 1] ubnd_in = [fitschan["NAXIS1"], fitschan["NAXIS2"]] # Get the rotation angle and convert from degrees to radians. angle = float(angle) * Ast.DD2R # Construct a MatrixMap that rotates by the required angle, converted to radians. sinang = math.sin(angle) cosang = math.cos(angle) pixmap = Ast.MatrixMap([[cosang, sinang], [-sinang, cosang]]) # If supplied, get the centre of rotation. if (xcen is not None) and (ycen is not None): # Create aShiftMap to shift the origin and combine it with the # MatrixMap, to give the desired centre of rotation (shift, # rotate, then shift back again). shiftmap = Ast.ShiftMap([-xcen, -ycen]) pixmap = Ast.CmpMap(shiftmap, pixmap) shiftmap.invert() pixmap = Ast.CmpMap(pixmap, shiftmap) # The dimensions of the output array are the same as the input array. lbnd_out = lbnd_in ubnd_out = ubnd_in # If no centre of rotation was specified, we use the MatrixMap # unchanged, and determine the bounds of the smallest output image that # will hold the entire rotated input image. These are with respect to # the pixel coordinates of the input array, and so some corners may have # negative pixel coordinates. else: (lb1, ub1, xl, xu) = pixmap.mapbox(lbnd_in, ubnd_in, 1) (lb2, ub2, xl, xu) = pixmap.mapbox(lbnd_in, ubnd_in, 2) lbnd_out = [int(lb1), int(lb2)] ubnd_out = [int(ub1), int(ub2)] # Get the value used to represent missing pixel values if "BLANK" in fitschan: badval = fitschan["BLANK"] flags = Ast.USEBAD else: badval = 0 flags = 0 # Resample the data array using the above mapping. (npix, out, out_var) = pixmap.resample(lbnd_in, ubnd_in, hdu_list[0].data, None, Ast.LINEAR, None, flags, 0.05, 1000, badval, lbnd_out, ubnd_out, lbnd_out, ubnd_out) # Store the rotated data in the HDU, and update the NAXISi keywords # to hold the number of pixels along each edge of the rotated image. hdu_list[0].data = out fitschan["NAXIS1"] = ubnd_out[0] - lbnd_out[0] + 1 fitschan["NAXIS2"] = ubnd_out[1] - lbnd_out[1] + 1 # Move the pixel origin of the output from "lbnd_out" to (1,1). Create a # suitable ShiftMap, and append it to the total "old pixel coord" to # "new pixel coords" mapping. shiftmap = Ast.ShiftMap([-lbnd_out[0], -lbnd_out[1]]) pixmap = Ast.CmpMap(pixmap, shiftmap) # Re-map the base Frame (i.e. the pixel coordinates Frame) so that it # refers to the new data grid instead of the old one. wcsinfo.remapframe(Ast.BASE, pixmap) # Attempt to write the modified WCS information to the primary HDU (i.e. # convert the FrameSet to a set of FITS header cards stored in the # FITS file). Indicate that we want to use original flavour of FITS-WCS. fitschan.Encoding = encoding fitschan.clear('Card') if fitschan.write(wcsinfo) == 0: print("Failed to convert the rotated WCS to Fits-WCS") # If successfull, force the FitsCHan to copy its contents into the # PyFITS header, then write the changed data and header to the output # FITS file. else: fitschan.writefits() hdu_list.writeto(outfile, clobber=True, output_verify='ignore')
#!/usr/bin/python3 import starlink.Ast as Ast bmask = open("bmask.log", "r") lut = [] igood = -0.5 for i in range(32): for j in range(40): maskin = bmask.readline().rstrip() if maskin == "BAD": lut.append(Ast.BAD) else: igood += 1 lut.append(igood) bmask.close() mapping = open("mapping.ast", "w") mapping.write( str( Ast.CmpMap(Ast.UnitMap(1), Ast.LutMap(lut, 0.5, 1.0, "LutInterp=1"), False))) mapping.close()