def makecuts(image,imagefilter): catdat= fits.getdata(args.catalog) print 'Cutting out', image zFlag = (catdat.Z > Zmin) & (catdat.Z < Zmax) f = fits.open(image) prihdr = f[0].header n2,n1 = f[0].data.shape w= WCS(image) px,py = w.wcs_world2pix(catdat.RA,catdat.DEC,1) onimageflag=(px < n1) & (px >0) & (py < n2) & (py > 0) keepflag=zFlag & onimageflag RA=catdat.RA[keepflag] DEC=catdat.DEC[keepflag] radius=catdat.SERSIC_TH50[keepflag] IDNUMBER=catdat.NSAID[keepflag] print 'number of galaxies to keep = ', sum(keepflag) # if args.region_file: for i in range(len(RA)): if (radius[i]<.01): size=120. else: size=float(args.scale)*radius[i] position = SkyCoord(ra=RA[i],dec=DEC[i],unit='deg') size = u.Quantity((size, size), u.arcsec) #print image, radius[i], position, size #cutout = Cutout2D(fdulist[0].data, position, size, wcs=w, mode='strict') #require entire image to be on parent image try: cutout = Cutout2D(f[0].data, position, size, wcs=w, mode='trim') #require entire image to be on parent image except astropy.nddata.utils.PartialOverlapError:# PartialOverlapError: print 'galaxy is only partially covered by mosaic - skipping ',IDNUMBER[i] continue except astropy.nddata.utils.NoOverlapError:# PartialOverlapError: print 'galaxy is not covered by mosaic - skipping ',IDNUMBER[i] continue if args.plot: plt.figure() plt.imshow(f[0].data, origin='lower',cmap='gray', norm=LogNorm()) cutout.plot_on_original(color='white') plt.show() r = raw_input('type any key to continue (p to skip plotting) \n') if r.find('p') > -1: args.plot = False # figure out how to save the cutout as fits image ((ymin,ymax),(xmin,xmax)) = cutout.bbox_original outimage = args.prefix+'-'+(str(IDNUMBER[i])+'-'+ args.filter+".fits") newfile = fits.PrimaryHDU() newfile.data = f[0].data[ymin:ymax,xmin:xmax] newfile.header = f[0].header newfile.header.update(w[ymin:ymax,xmin:xmax].to_header()) fits.writeto(outimage, newfile.data, header = newfile.header, clobber=True) return cutout
def splitkwaj(fn, outPath, outFN, nStart): '''Loads a 16-frame FITS file obtained from Kwajalein MIT/LL telescopes - saves a separate FITS files''' # Basic idea: # Kwaj FITS files have one primary header and 15 extensions, each with an # associated 1024x1024 image. We load these and save them individually with the # associated headers. hdu1 = pf.open(fn) # Write the image in the primary HDU to disk d = hdu1[0].data h = hdu1[0].header h.update('EXTEND', 'F') pf.writeto(outPath + outFN + "_" + str(nStart) + ".fits", d, h) # Now write the 15 extensions as individual FITS files fnX = ["01","02","03","04","05","06","07","08","09","10","11","12","13","14","15"] for i0 in range(15): i = i0 + 1 # skip the first image d = hdu1[i].data h = hdu1[i].header k = h.keys() hList = arange(43)+9 # indices of the keywords we want to keep hdu0 = pf.PrimaryHDU(d) # Make a new stub of a header for j in hList: hdu0.header.update(k[j], h[k[j]]) pf.writeto(outPath + outFN + "_" + str(nStart+i) + ".fits", d, hdu0.header) return
def export_to_fits(self, fitsfile='ModelDetectorCube'): header = self.wcs_info() slice_index = 0 for flux_plus_bg in self.flux_plus_bg_list: fitsfile_slice = fitsfile + str(slice_index).strip() + '.fits' fits.writeto(fitsfile_slice, np.rollaxis(flux_plus_bg, 2), header, clobber=True) fits.append(fitsfile_slice, self.wave)
def determine_ratio_baseline_sigma(plot=False): data = pyfits.getdata(fits_path+'local_counts_baseline.fits') el = data[:,:,0].astype(np.float) sp = data[:,:,1].astype(np.float) mask_el = el < 1 mask_sp = sp < 1 mask_all = np.logical_and(mask_el, mask_sp) mask = np.logical_or(mask_el, mask_sp) ratio = pyfits.getdata(fits_path+'local_ratio_baseline.fits') count_sum = (el + sp).astype(np.float) count_product = (el * sp).astype(np.float) np.putmask(count_product, mask, 1.0) np.putmask(count_sum, mask, 1.0) sigma = (np.log10(np.e))**2 * count_sum / count_product sigma = np.sqrt(sigma) np.putmask(sigma, mask, unknown_ratio) sigma_masked = ma.masked_less_equal(sigma, unknown_ratio) if plot: fig = plt.figure(3) fig.clf() ax = fig.add_subplot(111) im = ax.imshow(sigma_masked, interpolation='nearest', origin='lower') cb = plt.colorbar(im) ax.set_aspect('auto') ax.set_xlabel(r'$M_R [mag]$',fontsize=22) ax.set_ylabel(r'$R_{50} [kpc]$',fontsize=22) pyfits.writeto(fits_path+'local_ratio_baseline_sigma.fits', sigma, clobber=True)
def insert_fake_star(d,h,mag): """ Currently this function is NOT used """ xsize = h['NAXIS1'] ysize = h['NAXIS2'] #Insert fake star size = 5 x = np.random.random_sample()*(xsize-size+1)+(size+1) y = np.random.random_sample()*(ysize-size+1)+(size+1) #print(x,y) #x = 700 #y = 690 #print(x,y) magnitude = mag zp = 25. expfactor = (magnitude - zp)/(-2.5) counts = math.pow(10.,expfactor) #print(counts) g = gauss_kern(size,counts) #5 is rough guess for FWHM d[y-size:y+size+1,x-size:x+size+1] += g #Damn backward numpy arrays fits.writeto("TestOuput.fits",d,h,clobber=True) return(x,y,magnitude)
def get_usr_mask(self): print 'click on the location to add object mask' if args.nods9: a = self.fig.canvas.mpl_connect('button_press_event', self.onclick) while self.xcursor == self.xcursor_old: # stay in while loop until mouse is clicked plt.pause(1) else: self.ds9_onclick() # mask out a rectangle around click # size is given by mask_size xmin = int(self.xcursor) - int(0.5*self.mask_size) ymin = int(self.ycursor) - int(0.5*self.mask_size) xmax = int(self.xcursor) + int(0.5*self.mask_size) ymax = int(self.ycursor) + int(0.5*self.mask_size) # make sure mask dimensions are not outside of the image if xmin < 0: xmin = 0 if ymin < 0: ymin = 0 if xmax > self.xmax: xmax = self.xmax if ymax > self.ymax: ymax = self.ymax print 'xcursor, ycursor = ',self.xcursor, self.ycursor mask_value = np.max(self.maskdat) + 1 self.usr_mask[ymin:ymin+int(self.mask_size),xmin:xmin+int(self.mask_size)] = mask_value*np.ones([self.mask_size,self.mask_size]) self.maskdat = self.maskdat + self.usr_mask fits.writeto(self.mask_image, self.maskdat, header = self.imheader, clobber=True) print('added mask object '+str(mask_value)) self.xcursor_old = self.xcursor
def trim_image(image, cra, cdec, xsize, ysize, outname): '''Trim images and maintain WCS. Provide the center of the field and desired size xsize,ysize given in arcmin ''' im,hdr = fits.getdata(image, header=True) hdr_wcs = pywcs.WCS(hdr) # convert size to pixels xs = xsize * 60. / hdr['SECPIX1'] ys = ysize * 60. / hdr['SECPIX2'] # update header to have correct WCS # from Adam Ginsburg's cutout.py hdr['CRPIX1'] = xs / 2. hdr['CRPIX2'] = ys / 2. hdr['CRVAL1'] = cra hdr['CRVAL2'] = cdec hdr['NAXIS1'] = int(xs) hdr['NAXIS2'] = int(ys) # find center of WISP field in Palomar pixel coordinates pix = hdr_wcs.wcs_sky2pix([[cra,cdec]],1) x1 = pix[0][0] - xs/2. x2 = pix[0][0] + xs/2. y1 = pix[0][1] - ys/2. y2 = pix[0][1] + ys/2. new = im[y1:y2,x1:x2] fits.writeto(outname, new, header=hdr, clobber=True)
def submit(event): try: pyfits.writeto(self.model_location+'/xmod.fits', xparams,clobber=True) print('Data updated on xmod.fits') return 1 except Exception: print('Unable to save data onto file.')
def checkSkylines(filename,min_lambda,max_lambda,sumRow,outname): file = fits.open(filename) data = file[0].data hdr = file[0].header sizeLambda = data.shape[2] min_image_lambda = hdr['CRVAL1'] delta_lambda = hdr['CDELT1'] min_pixel = int(round((min_lambda - min_image_lambda) / delta_lambda)) max_pixel = int(round((max_lambda - min_image_lambda) / delta_lambda)) if (min_pixel >= max_pixel): sys.exit("Max lambda needs to be greater than min lambda") if (min_pixel < 0): sys.exit("Selected minimum wavelength is off detector") if (max_pixel > sizeLambda): sys.exit("Selected maximum wavelength is off detector") onlyLine = data[:,:,min_pixel:max_pixel] sumLine = np.sum(onlyLine,axis=2) sumRowOnly = sumLine[:,sumRow] totalRMS = np.std(sumLine) rowRMS = np.std(sumRowOnly) fits.writeto(outname,sumLine,clobber=True) return totalRMS, rowRMS
def PlotTSmap(self) : """ Gather the results of the evaluation of each pixel and fill a fits file""" folder = self.config['out'] # Read the cmap produced before to get the grid for the TS map FitRunner = Observation(folder, self.config) try : header = fits.getheader(FitRunner.cmapfile) except : self.error('Count map not found.') data = fits.getdata(FitRunner.cmapfile)*0. npix_im = min(header['NAXIS1'],header['NAXIS2']) npix = min(self.config['TSMap']['npix'],npix_im) Xref = header['CRPIX1'] Yref = header['CRPIX2'] binsz = header['CDELT1'] import string # read the results for i in xrange(npix): for j in xrange(npix): try : lines = open(self._PixelFile(i,j),"r").readlines() Value = float(string.split(lines[0])[2]) except : self.warning("Cannot find, open or read "+self._PixelFile(i,j)) Value = 0. data[Xref+ (i-npix/2.)][Yref+ (j-npix/2.)] = Value # save in a fits files fits.writeto(folder+"/"+self.TSfits,data,header) self.info("TS Map saved in "+folder+"/"+self.TSfits)
def main(fname, output=False, unit=1, clobber=True): '''Convert the CRIRES spectrum to a 1D spectrum Input: fname: Fits file of CRIRES spectrum output: Name of output file. Default is: "wmin-wmax.fits" unit: Unit of wavelength vector (Angstrom is default.) clobber: Overwrite existing files ''' I = fits.getdata(fname) w = _get_wavelength(fname, unit=unit) if not output: output = '%i-%i.fits' % (w.min(), w.max()) else: if not output.lower().endswith('.fits'): output += '.fits' N = len(w) hdr = fits.Header() hdr["NAXIS1"] = N hdr["CDELT1"] = (w[-1]-w[0])/N hdr["CRVAL1"] = w[0] fits.writeto(output, I['Extracted_OPT'], header=hdr, clobber=clobber) print('File writed to: {}'.format(output))
def poly(n,zi,dz,filename): ''' Integrates the L-E equation and returns and writes to a file the important values. n is the index, zi is the interval to use the polynomial solution, dz is the step size, filename is the prefix for the output file (filename+.fits) ''' #set up equation and variables LEeq = LEeqn(n) zs = np.arange(0.,zi,dz) nz = np.size(zs) #integrate over initial interval using polynomial y = intg.odeint(thPN,np.array([1.,0.]),zs) #integrate until th<0 while y[-1,0]>0.: zs2 = np.arange(zs[-1],zs[-1]+200.*dz,dz) zs = np.append(zs,zs2) y = np.append(y,intg.odeint(LEeq,y[-1],zs2),axis=0) #write progress sys.stdout.write("\rz={0},th={1}".format(zs[-1],y[-1,0])) sys.stdout.flush() sys.stdout.write("\n") #only keep values where th>0 ngood= np.size(np.where(y[:,0]>0.)) zs = zs[:ngood] y = y[:ngood] #prepare output array data = np.array([zs,y[:,0],-(zs**2)*y[:,1],(-3./zs)*y[:,1]]) #write and return data fits.writeto(filename+'.fits',data) return data
def fix_header(image, wispfield): '''Fix the DATASEC keyword in the image's header to extend out to the full size of the image. After IRAF's imcombine, the DATASEC keyword should have been updated to include the new size of the image Add the total exposure time of the combined images to the header ''' im,hdr = fits.getdata(image, header=True) nx1 = hdr['NAXIS1'] nx2 = hdr['NAXIS2'] hdr['DATASEC'] = '[1:%i,1:%i]' % (nx1-1, nx2-1) if 'TEXPTIME' not in hdr: ims = hdr['IMCMB*'] Nim = len(ims) texptime = 0. # add up all the exposure times for i in range(Nim): if os.path.splitext(ims[i])[1] != '.fits': ims[i] = ims[i] + '.fits' thdr = fits.getheader(os.path.join(wispfield,ims[i])) texptime += thdr['exptime'] hdr.insert(19, ('TEXPTIME', texptime, 'Total EXPTIME of combined images')) fits.writeto(image, im, hdr, clobber=True)
def linearity_correction(image_list): if "--shutter" in sys.argv: #self_seach_pattern = patt_shutter_correc self_seach_pattern = patt_bias_corrected # remove once shutter is implemented and uncomment previous else: self_seach_pattern = patt_bias_corrected length = len(image_list) * len(quadrants) for k in range(len(quadrants)): e = quadrants[k] for i in range(len(image_list)): current= i + k*len(image_list) print_progress(current,length) image = proc_data_path + self_seach_pattern + image_list[i] + "c%s.fits"%e #print image data,header= get_data_header(image) header["COMMENT"] = ("linearity corrected image \ Added by %s"%my_name) c2 = linear_c2[e-1] c3 = linear_c3[e-1] alpha = linear_alpha[e-1] lc_data = correct.linear(data,c2,c3,alpha) # = data lc_image = proc_data_path + patt_linearity_corr + image_list[i] + "c%s.fits"%e #print lc_image fits.writeto(lc_image,data,header,clobber=True) #print_progress(i,len(image_list)) return
def createVoronoiOutput(inputFile=datadir+cuberoot+'.fits',inputVoronoiFile=datadir+'voronoi_2d_binning_output.txt'): cubefits = pyfits.open(inputFile) cube = cubefits[0].data hdr = cubefits[0].header errors = cubefits[1].data quality = cubefits[2].data nframes = cubefits[3].data cubeShape = (cube.shape[0],cube.shape[1],cube.shape[2]) yy, xx, binnum = np.loadtxt(inputVoronoiFile,unpack=True) xx = xx.astype(int) yy = yy.astype(int) binnum = binnum.astype(int) newCube = np.zeros(cubeShape, dtype=float) newErr = np.zeros(cubeShape, dtype=float) for nb in range(binnum.max()+1): idx = np.where(binnum == nb) nx = xx[idx] ny = yy[idx] nbins = len(idx[0]) tmpCube = np.sum(cube[nx,ny,:],axis=0)/nbins tmpErr = np.sqrt(np.sum(errors[nx,ny,:]**2,axis=0))/nbins newCube[nx,ny,:] = tmpCube newErr[nx,ny,:] = tmpErr #pdb.set_trace() outfile = inputFile.replace('.fits','_vorcube.fits') pyfits.writeto(outfile,newCube,header=hdr) pyfits.append(outfile,newErr) pyfits.append(outfile,quality) pyfits.append(outfile,nframes)
def pngsToFits(self, overwrite = False): """ Converts each PNG file to three FITS files, once per color. :param overwrite: :return: """ for i, ZooID in enumerate(self.catalog['ZooID']): if self.test_mode and i > 5: break #find images basic_name = str(i) + '_' + ZooID png_path = os.path.join(self.path_to_data, "cutouts/png", basic_name + ".png") img = Image.open(png_path) img_by_color = [self.imgToRgbArray(img)[:,:,c] for c in range(3)] for c in range(3): fits_path = self.make_img_path(i, ZooID, True, c) #open, convert, save if os.path.exists(fits_path): if overwrite: warnings.warn("Overwriting FITS files.") os.remove(fits_path) else: warnings.warn("Leaving existing FITS files untouched.") continue fits.writeto(fits_path, data = img_by_color[c]) return
def export_to_fits(self, fitsfile='ModelSceneCube.fits'): """ Write model cube to a FITS file """ header = self.grid.wcs_info() fits.writeto(fitsfile, np.rollaxis(self.int, 2), header, clobber=True) fits.append(fitsfile, self.wave)
def save_reduced_data(input_file,sp,unc,wave=None): print 'Saving extraction as %s'%(os.path.splitext(input_file)[0]+'_reduced.fits') #load up file to grab header to append reduction information to hdulist=loadfits(input_file) head=hdulist[0].header head['ORDERS'] = (sp.shape[1], 'Number of orders reduced') #append header field 'how many orders',len(ord) head['REDUTIME'] = (strftime("%c"), 'When reduced') #append header field 'when reduced', time.strftime("%c") head['comment'] = 'data saved as (ext,unc,wave) for each order' if wave==None: wave=np.arange(sp.shape[0]) data=[[]]*(sp.shape[1]+1) for i in np.arange(sp.shape[1]): data=np.vstack((sp[:,i],unc[:,i],wave[i,:][::-1])) if i==0: head['ORDER']=((i+1),'Order number') pyfits.writeto(os.path.splitext(input_file)[0]+'_reduced.fits', data,head, clobber=True) else: head['ORDER']=((i+1),'Order number') pyfits.append(os.path.splitext(input_file)[0]+'_reduced.fits', data,head) #save file as original file + _reduced #ie. if aug008811.fits was the file - this becomes #aug008811_reduced.npy hdulist.close()
def write_tblspec(flux, wave, loglam, objtype): data = dict(flux=flux) hdr = dict(FLUXUNIT='erg/s/cm^2/A') if wave is None: if loglam: hdr['LOGLAM'] = loglam hdr['CRVAL1'] = np.log10(wave1D[0]) hdr['CDELT1'] = np.log10(1+dwave/wave1D[0]) else: if loglam is not None: hdr['LOGLAM'] = loglam hdr['CRVAL1'] = wave1D[0] hdr['CDELT1'] = dwave else: if loglam is None or not loglam: data['wavelength'] = wave else: data['loglam'] = wave if type(objtype) == str: hdr['OBJTYPE'] = objtype else: data['objtype'] = objtype['OBJTYPE'] filename = get_next_filename() fits.writeto(filename, data, header=hdr, clobber=True) return filename
def write_imgspec(flux, wave, loglam, objtype): hdr = dict(FLUXUNIT='erg/s/cm^2/A') if wave is None: if loglam: hdr['LOGLAM'] = loglam hdr['CRVAL1'] = np.log10(wave1D[0]) hdr['CDELT1'] = np.log10(1+dwave/wave1D[0]) else: if loglam is not None: hdr['LOGLAM'] = loglam hdr['CRVAL1'] = wave1D[0] hdr['CDELT1'] = dwave if type(objtype) == str: hdr['OBJTYPE'] = objtype filename = get_next_filename() fits.writeto(filename, flux, header=hdr, clobber=True) if wave is not None: if loglam: fits.append(filename, wave, extname='LOGLAM') else: fits.append(filename, wave, extname='WAVELENGTH') if type(objtype) != str: fits.append(filename, objtype, extname='TARGETINFO') return filename
def immultiply( image, scalefactor, outfile=None, clobber=False, verbose=False): """ Multiply the image by scalefactor. If a string is provided for outfile, then the resulting scaled image file is written to that file name. Otherwise, the scaled image data array is returned. """ import os from numpy import ndarray import exceptions # read in the image if isinstance( image, str ): if not os.path.isfile( image ) : raise exceptions.RuntimeError( "The image file %s is not valid."%image ) im1head = pyfits.getheader( image ) im1data = pyfits.getdata( image ) im1head["FLXSCALE"] = (scalefactor,"Flux scaling factor") elif isinstance( image, ndarray ): im1data = image im1head = None else : raise exceptions.RuntimeError("Provide a fits file name or numpy array for each image.") scaledim = scalefactor * im1data if outfile : outdir = os.path.split( outfile )[0] if outdir : if not os.path.isdir(outdir): os.makedirs( outdir ) pyfits.writeto( outfile, scaledim, header=im1head,clobber=clobber ) return( outfile ) else : return( scaledim )
def main(self, list_of_files): self.print_header() log.info('Processing data') list_of_files = sorted(list_of_files) for filename in list_of_files: prefix = "cr" # Get joined data data = pyfits.getdata(filename) # Build header header = pyfits.getheader(filename) # Remove cosmic rays and hot pixels data, header, prefix = self.remove_cosmic_rays( data, header, prefix) # Writing file header.add_history('Cosmic Rays removed.') path, filename = os.path.split(filename) pyfits.writeto(os.path.join(path, prefix + filename), data, header, clobber=True) log.info("\n All done!")
def part_5(): for i in range(len(object_list)): outfile = open(object_list[i]+'.CMsub.file.list','w') outfile.write('# '+'%16s'%'file name\n') infile = open('star_coord_'+object_list[i]+'.dat','r') for line in infile.readlines(): if not line.startswith('#'): entries = line.split() filename,x_cen,y_cen = str(entries[0]),float(entries[1]),float(entries[2]) f = fits.open(filename) scidata = f[0].data radial_bins = np.linspace(0,1000,1001) radial_displ = np.zeros([1024,1024]) for y in range(1024): for x in range(1024): radial_displ[y,x] = int(sqrt((y-y_cen)**2+(x-x_cen)**2)) max_radius = int(np.max(radial_bins)) concen_radius = np.linspace(0,max_radius,max_radius+1) concen_median = np.zeros(max_radius+1) concen_values = [[]] for j in range(max_radius+1): concen_values.append([]) for y in range(1024): for x in range(1024): concen_values[int(radial_displ[y,x])].append(scidata[y,x]) for j in range(max_radius+1): concen_median[j] = np.median(concen_values[j]) cm_pix_val = np.zeros([1024,1024]) for y in range(1024): for x in range(1024): cm_pix_val[y,x] = concen_median[int(radial_displ[y,x])] newfilename = filename[:len(filename)-8]+'concen_median.fits' os.system('rm -f '+newfilename) fits.writeto(newfilename,cm_pix_val,f[0].header) CMsubtracted = scidata -cm_pix_val newfilename = filename[:len(filename)-8]+'CMsubtracted.fits' os.system('rm -f '+newfilename) fits.writeto(newfilename,CMsubtracted,f[0].header) f.close() print('wrote '+newfilename) outfile.write(newfilename+'\n') outfile.close() infile.close() part_3(5) part_4(5)
def write_fits(fitsfilename, array, header=None, precision=np.float32, verbose=True): """ Write array and header into FTIS file. If there is a previous file with the same filename then it's replaced. Parameters ---------- fitsfilename : string Full path of the fits file to be written. array : numpy ndarray Array to be written into a fits file. header : numpy ndarray, optional Array with header. precision : numpy dtype, optional Float precision, by default np.float32 or single precision float. verbose : bool, optional If True prints message. """ array = array.astype(precision, copy=False) if not fitsfilename.endswith('.fits'): fitsfilename += '.fits' if os.path.exists(fitsfilename): os.remove(fitsfilename) ap_fits.writeto(fitsfilename, array, header) if verbose: print("Fits file successfully overwritten") else: ap_fits.writeto(fitsfilename, array, header) if verbose: print("Fits file successfully saved")
def dark_subtract(imlist, MasterDark, SaveSteps=False): '''Dark subtract the images in imlist using the previously combined Master Dark frame. Scale the Master Dark up to the exptime of each image before subtraction. Set SaveSteps = True to write each dark-subtracted image to a new file named [input_image].ds.fits. This option is good for checking the reduction at each step. Default is to overwrite input image files. ''' # read in Master Dark frame Dark = fits.getdata(MasterDark) # get the date and time now = time.strftime('%c') for image in imlist: im,hdr = fits.getdata(image, header=True) # write a keyword to header darkstr = 'Dark subtracted: %s' % now hdr['DARKSUB'] = darkstr # output file name if SaveSteps: output = ''.join([os.path.splitext(image)[0], '.ds.fits']) else: output = image # scale Dark up to exptime of image exptime = hdr['EXPTIME'] ScaledDark = Dark * exptime new = im - ScaledDark fits.writeto(output, new, header=hdr, clobber=True) return
def export_to_fits(cli): # # Read in the model: # file = filename(cli, "plot") file += ".rtout" model = ModelOutput(file) # # Write fits file: # if(cli.mode == "images"): los = [0 for i in range(3)] los[0] = 'x' los[1] = 'y' los[2] = 'z' for k in range(0, 3): image = model.get_image(distance=1*pc, units='MJy/sr', inclination=0, component='total', group=k) Nwavelength=image.val.shape[2] for i in range(0, Nwavelength): file = filename(cli, "fits") file += "_wavelength=" + str(image.wav[i]) + "micron_los=" + los[k] + ".fits" fits.writeto(file, image.val[:, :, i], clobber=True) if(cli.verbose): print(" The fits file was written to", file) else: print("ERROR: The specified mode", mode, "is not available. Use 'images' only.")
def write_mle_tofits(filename='', vel_widths=None, dgrs=None, likelihoods=None, clobber=False): from astropy.io import fits print('Writing likelihood grid to file:') print(filename) header = fits.Header() header['NAXIS'] = 2 header['CTYPE1'] = 'WIDTHS' header['CTYPE2'] = 'DGR' header['CRPIX1'] = 0 header['CRPIX2'] = 0 header['CRVAL1'] = vel_widths[0] header['CRVAL2'] = dgrs[0] try: header['CDELT1'] = vel_widths[1] - vel_widths[0] except IndexError: header['CDELT1'] = 1 try: header['CDELT2'] = dgrs[1] - dgrs[0] except IndexError: header['CDELT2'] = 1 fits.writeto(filename, likelihoods, header, clobber=clobber)
def write_data(data, header, filename): pf.writeto(filename, data, header = header, clobber = True, output_verify = 'fix')
def bfixpix(image_file, mask_file, outsuffix='_f', msksuffix='_s'): """ Inputs --------- image_file : string input image file to fix bad pixels on mask_file : string mask file (0 == good pixels, >0 == bad pixels outsuffix : string suffix for fixed image. default = '_f' msksuffix : string suffix for bad pixels significance mask. default = '_s' """ outf = image_file.replace('.fits', outsuffix + '.fits') outm = image_file.replace('.fits', msksuffix + '.fits') util.rmall([outf, outm]) print("bfixpix: {0} -> {1}".format(image_file, outf)) # fetch the image, fetch the mask img, hdr = fits.getdata(image_file, header=True) msk = fits.getdata(mask_file) # median the image medimg = ndimage.median_filter(img, 3, mode='nearest') # generate the pixel files outf_img = np.where(msk == 0, img, medimg) outm_img = np.where(msk == 1, (img - medimg), 0) fits.writeto(outf, outf_img, hdr) fits.writeto(outm, outm_img, hdr)
def significance_image(infile, outfile, theta, overwrite): """Make correlated significance image. TODO: describe """ from astropy.io import fits from gammapy.image import disk_correlate from gammapy.stats import significance_on_off log.info('Reading {0}'.format(infile)) hdus = fits.open(infile) n_on = hdus['On'].data n_off = hdus['Off'].data a_on = hdus['OnExposure'].data a_off = hdus['OffExposure'].data log.info('Correlating n_on and a_on map') theta = theta / hdus['On'].header['CDELT2'] n_on = disk_correlate(n_on, theta) a_on = disk_correlate(a_on, theta) log.info('Computing significance map') alpha = a_on / a_off significance = significance_on_off(n_on, n_off, alpha) log.info('Writing {0}'.format(outfile)) fits.writeto(outfile, data=significance, header=hdus['On'].header, clobber=overwrite)
def create_mask(self, img, seeing_fwhm, step=0): # remove_border = True # sextractor takes care of bad pixels # if seeing_fwhm is not None and seeing_fwhm > 0: # sex.config['SEEING_FWHM'] = seeing_fwhm * sex.config['PIXEL_SCALE'] if remove_border: weigthmap = 'weights4rms.fits' # Create weight map, remove n pixs from either side # using a Hannig filter # npix = 90 # w1 = npix # w2 = npix # wmap = numpy.ones_like(sf_data[0]) # cos_win1 = numpy.hanning(2 * w1) # cos_win2 = numpy.hanning(2 * w2) # wmap[:,:w1] *= cos_win1[:w1] # wmap[:,-w1:] *= cos_win1[-w1:] # wmap[:w2,:] *= cos_win2[:w2, numpy.newaxis] # wmap[-w2:,:] *= cos_win2[-w2:, numpy.newaxis] # Take the number of combined images from the combined image wm = img[2].data.copy() # Dont search objects where nimages < lower # FIXME: this is a magic number # We ignore objects in regions where we have less # than 10% of the images lower = wm.max() // 10 border = (wm < lower) fits.writeto(weigthmap, border.astype('uint8'), overwrite=True) # sex.config['WEIGHT_TYPE'] = 'MAP_WEIGHT' # FIXME: this is a magic number # sex.config['WEIGHT_THRESH'] = 50 # sex.config['WEIGHT_IMAGE'] = weigthmap else: border = None data_res = img[0].data bkg = sep.Background(data_res) data_sub = data_res - bkg self.logger.info('Runing source extraction in previous result') objects, objmask = sep.extract(data_sub, 1.5, err=bkg.globalrms, mask=border, segmentation_map=True) fits.writeto(name_segmask(step), objmask, overwrite=True) # # Plot objects # # FIXME, plot sextractor objects on top of image # patches = [] # fwhms = [] # nfirst = 0 # catalog_f = sopen(sex.config['CATALOG_NAME']) # try: # star = catalog_f.readline() # while star: # flags = star['FLAGS'] # # ignoring those objects with corrupted apertures # if flags & sexcatalog.CORRUPTED_APER: # star = catalog_f.readline() # continue # center = (star['X_IMAGE'], star['Y_IMAGE']) # wd = 10 * star['A_IMAGE'] # hd = 10 * star['B_IMAGE'] # color = 'red' # e = Ellipse(center, wd, hd, star['THETA_IMAGE'], color=color) # patches.append(e) # fwhms.append(star['FWHM_IMAGE']) # nfirst += 1 # # FIXME Plot a ellipse # star = catalog_f.readline() # finally: # catalog_f.close() # # p = PatchCollection(patches, alpha=0.4) # ax = self._figure.gca() # ax.add_collection(p) # self._figure.canvas.draw() # self._figure.savefig('figure-segmentation-overlay_%01d.png' % step) # # self.figure_fwhm_histogram(fwhms, step=step) # # # mode with an histogram # hist, edges = numpy.histogram(fwhms, 50) # idx = hist.argmax() # # seeing_fwhm = 0.5 * (edges[idx] + edges[idx + 1]) # if seeing_fwhm <= 0: # _logger.warning( # 'Seeing FHWM %f pixels is negative, reseting', seeing_fwhm) # seeing_fwhm = None # else: # _logger.info('Seeing FHWM %f pixels (%f arcseconds)', # seeing_fwhm, seeing_fwhm * sex.config['PIXEL_SCALE']) # objmask = fits.getdata(name_segmask(step)) return objmask, seeing_fwhm
plt.xlabel('g magnitude') pl.show() pl.clf() for i, x in enumerate(flux): pl.semilogy(wave, x, label=str(meta['r'][i])) pl.legend(ncol=4) pl.show() if save: meta.write(meta_name, format='ascii', overwrite=True) hdr = fits.Header() hdr['EXTNAME'] = 'WAVELENGTH' hdr['BUNIT'] = 'Angstrom' fits.writeto(infile, wave, header=hdr, overwrite=True) hdr['EXTNAME'] = 'FLUX' hdr['BUNIT'] = '10^-17 erg/(s*cm^2*Angstrom)' # Satisifes FITS standard AND Astropy-compatible. fits.append(infile, flux, header=hdr) print('\n\nWritten to %s.' % infile) print('\n\nDone.\n\n')
def process_advanced(self, images_info, result, step, target_is_sky=True, maxsep=5.0, nframes=6, extinction=0, method=None, method_kwargs=None): seeing_fwhm = None baseshape = (EMIR_NAXIS2, EMIR_NAXIS1) target_info = [iinfo for iinfo in images_info if iinfo.valid_target] sky_info = [iinfo for iinfo in images_info if iinfo.valid_sky] self.logger.info('Step %d, generating segmentation image', step) objmask, seeing_fwhm = self.create_mask(result, seeing_fwhm, step=step) for frame in target_info: frame.objmask = name_object_mask(frame.label, step) self.logger.info('Step %d, create object mask %s', step, frame.objmask) frame.objmask_data = objmask[frame.valid_region] fits.writeto(frame.objmask, frame.objmask_data, overwrite=True) if not target_is_sky: # Empty object mask for sky frames bogus_objmask = numpy.zeros(baseshape, dtype='uint8') for frame in sky_info: frame.objmask_data = bogus_objmask self.logger.info("Step %d, SF: compute superflat", step) sf_arr = self.compute_superflat(sky_info, segmask=objmask, step=step, method=method, method_kwargs=method_kwargs) # Apply superflat self.logger.info("Step %d, SF: apply superflat", step) for iinfo in images_info: self.correct_superflat(iinfo, sf_arr, step=step, save=True) self.logger.info('Step %d, advanced sky correction (SC)', step) self.compute_advanced_sky(target_info, objmask, skyframes=sky_info, target_is_sky=target_is_sky, maxsep=maxsep, nframes=nframes, step=step, method=method, method_kwargs=method_kwargs) # Combining the images self.logger.info("Step %d, Combining the images", step) # FIXME: only for science result = self.combine_frames(target_info, extinction, step=step, method=method, method_kwargs=method_kwargs) return result
def compute_advanced_sky_for_frame(self, frame, skyframes, step=0, save=True, method=None, method_kwargs=None): self.logger.info('Correcting sky in frame %s', frame.lastname) self.logger.info('with sky computed from frames') for i in skyframes: self.logger.info('%s', i.flat_corrected) data = [] scales = [] masks = [] # handle the FITS file to close it finally desc = [] try: for i in skyframes: filename = i.flat_corrected hdulist = fits.open(filename, mode='readonly', memmap=True) data.append(hdulist['primary'].data[i.valid_region]) desc.append(hdulist) scales.append(numpy.median(data[-1])) if i.objmask_data is not None: masks.append(i.objmask_data) self.logger.debug('object mask is shared') elif i.objmask is not None: hdulistmask = fits.open(i.objmask, mode='readonly', memmap=True) masks.append(hdulistmask['primary'].data) desc.append(hdulistmask) self.logger.debug('object mask is particular') else: self.logger.warn('no object mask for %s', filename) self.logger.debug("computing background with %d frames using '%s'", len(data), method.__name__) sky, _, num = method(data, masks, scales=scales, **method_kwargs) with fits.open(frame.lastname) as hdulist: data = hdulist['primary'].data valid = data[frame.valid_region] if frame.objmask_data is not None: self.logger.debug('object mask defined') msk = frame.objmask_data skymedian = numpy.median(valid[msk == 0]) else: self.logger.debug('object mask empty') skymedian = numpy.median(valid) self.logger.debug('scaling with skymedian %s', skymedian) sky *= skymedian finally: # Closing all FITS files for hdl in desc: hdl.close() if numpy.any(num == 0): # We have pixels without # sky background information self.logger.warning( 'pixels without sky information when correcting %s', frame.flat_corrected) binmask = num == 0 # FIXME: during development, this is faster # sky[binmask] = sky[num != 0].mean() # To continue we interpolate over the patches narray.fixpix2(sky, binmask, out=sky, iterations=1) name = name_skybackgroundmask(frame.label, step) fits.writeto(name, binmask.astype('int16'), overwrite=True) name_sky = name_skybackground(frame.label, step) fits.writeto(name_sky, sky, overwrite=True) dst = name_skysub_proc(frame.label, step) prev = frame.lastname shutil.copyfile(prev, dst) frame.lastname = dst with fits.open(frame.lastname, mode='update') as hdulist: data = hdulist['primary'].data valid = data[frame.valid_region] valid -= sky # ToDo: ad hoc sky correction adhoc_correction = False if adhoc_correction: print('---') print(frame) print('*** adhoc_correction ***') skycorr = self.sky_adhoc_correction(valid, frame.objmask_data) valid -= skycorr
from astropy.io import fits from hyperion.model import ModelOutput from hyperion.util.constants import pc # Retrieve image cube as before m = ModelOutput('simple_cube.rtout') image = m.get_image(inclination=0, distance=300 * pc, units='MJy/sr') # The image extracted above is a 3D array. We can write it out to FITS. # We need to swap some of the directions around so as to be able to use # the ds9 slider to change the wavelength of the image. fits.writeto('simple_cube.fits', image.val.swapaxes(0, 2).swapaxes(1, 2), clobber=True) # We can also just output one of the wavelengths fits.writeto('simple_cube_slice.fits', image.val[:, :, 1], clobber=True)
def combine_frames(self, frames, extinction, out=None, step=0, method=None, method_kwargs=None): self.logger.debug('Step %d, opening sky-subtracted frames', step) def fits_open(name): """Open FITS with memmap in readonly mode""" return fits.open(name, mode='readonly', memmap=True) frameslll = [ fits_open(frame.lastname) for frame in frames if frame.valid_target ] self.logger.debug('Step %d, opening mask frames', step) mskslll = [ fits_open(frame.resized_mask) for frame in frames if frame.valid_target ] self.logger.debug("Step %d, combining %d frames using '%s'", step, len(frameslll), method.__name__) try: extinc = [ pow(10, -0.4 * frame.metadata['airmass'] * extinction) for frame in frames if frame.valid_target ] data = [i['primary'].data for i in frameslll] masks = [i['primary'].data for i in mskslll] headers = [i['primary'].header for i in frameslll] out = method(data, masks, scales=extinc, dtype='float32', out=out, **method_kwargs) base_header = headers[0] hdu = fits.PrimaryHDU(out[0], header=base_header) hdu.header['history'] = "Combined %d images using '%s'" % ( len(frameslll), method.__name__) hdu.header['history'] = 'Combination time {}'.format( datetime.datetime.utcnow().isoformat()) for img in frameslll: hdu.header['history'] = "Image {}".format( img[0].header['uuid']) prevnum = base_header.get('NUM-NCOM', 1) hdu.header['NUM-NCOM'] = prevnum * len(frameslll) hdu.header['NUMRNAM'] = 'FullDitheredImagesRecipe' hdu.header['UUID'] = str(uuid.uuid1()) hdu.header['OBSMODE'] = 'FULL_DITHERED_IMAGE' # Headers of last image hdu.header['TSUTC2'] = headers[-1]['TSUTC2'] varhdu = fits.ImageHDU(out[1], name='VARIANCE') num = fits.ImageHDU(out[2].astype('uint8'), name='MAP') result = fits.HDUList([hdu, varhdu, num]) # saving the three extensions fits.writeto('result_i%0d.fits' % step, out[0], overwrite=True) fits.writeto('result_i%0d_var.fits' % step, out[1], overwrite=True) fits.writeto('result_i%0d_npix.fits' % step, out[2], overwrite=True) result.writeto('result_i%0d_full.fits' % step, overwrite=True) return result finally: self.logger.debug('Step %d, closing sky-subtracted frames', step) for f in frameslll: f.close() self.logger.debug('Step %d, closing mask frames', step) for f in mskslll: f.close()