def pop_interpolatedImage(self,LC,ind):
    #These should really be saved in the photometry file and grabbed from there...
    interpolation = "linear"
    aper_radius = 5
    annulus_inner = 10
    annulus_outer = 15
    
    image = LC.im_dict['images'][ind]
    centroid = LC.centroids[ind]
    interpImage = utils.interpolateImage(image, method=interpolation)
    angleArray = np.linspace(0,2*np.pi,180)
    
    self.plotArray(image=interpImage, title='Interpolated Image',cmap=matplotlib.cm.gnuplot2)
    for star_i in range(len(centroid)):
        self.axes.plot(centroid[star_i][0]+aper_radius*np.cos(angleArray), centroid[star_i][1] + aper_radius*np.sin(angleArray), 'b-')
        self.axes.plot(centroid[star_i][0]+annulus_inner*np.cos(angleArray), centroid[star_i][1] + annulus_inner*np.sin(angleArray), 'r-')
        self.axes.plot(centroid[star_i][0]+annulus_outer*np.cos(angleArray), centroid[star_i][1] + annulus_outer*np.sin(angleArray), 'r-')
Esempio n. 2
0
def pop_interpolatedImage(self,LC,ind):
    interpolation = LC.photometry_dict['interpolation'][ind]
    aper_radius = LC.photometry_dict['apertureRad'][ind]
    annulus_inner = LC.photometry_dict['annulusInnerRad'][ind]
    annulus_outer = LC.photometry_dict['annulusOuterRad'][ind]
    
    image = LC.im_dict['images'][ind]
    centroids = LC.centroids[ind]
    interpImage = utils.interpolateImage(image, method=interpolation)
    angleArray = np.linspace(0,2*np.pi,180)
    
    self.plotArray(image=interpImage, title='Interpolated Image',cmap=matplotlib.cm.gnuplot2)
    for star_i in range(len(centroids)):
        self.axes.plot(centroids[star_i][0]+aper_radius[star_i]*np.cos(angleArray), centroids[star_i][1] + aper_radius[star_i]*np.sin(angleArray), 'b-')
        self.axes.plot(centroids[star_i][0]+annulus_inner[star_i]*np.cos(angleArray), centroids[star_i][1] + annulus_inner[star_i]*np.sin(angleArray), 'r-')
        self.axes.plot(centroids[star_i][0]+annulus_outer[star_i]*np.cos(angleArray), centroids[star_i][1] + annulus_outer[star_i]*np.sin(angleArray), 'r-')
        
        self.axes.plot(centroids[star_i][0],centroids[star_i][1],'gx')
    def AperPhotometry(self, aper_radius=5, sky_sub="median", annulus_inner=10, annulus_outer=15, interpolation="linear"):
        '''
        Inputs:
            aper_radius - double or list of doubles of the same length as self.centroid. Number of pixels around the star to be used in aperture
            sky_sub - indicates type of sky subtraction to be performed.
                      "median" - to use median sky value in annulus
                      "fit" - to mask objects and estimate sky in aperture with polynomial fit
            annulus_inner - double or list of doubles of same length as self.centroid. Gives radius of inner part of sky annulus for use in "median" sky sub. Ignored if sky_sub is not "median" [target_apertureRad, ref0_apertureRad, ...]
            annulus_outer - double or list of doubles of same length as self.centroid. Gives radius of outer part of sky annulus for use in "median" sky sub. Ignored if sky_sub is not "median"
            interpolation - select type of interpolation to perform on image before doing photometry
                            None - to skip interpolation
                            "cubic" - to do 2D cubic interpolation
                            "linear" - to do 2D linear interpolation (default)
                            
        Returns: Dictionary with keywords. These keywords should be the same as in aperPhotometryDataDescription in headers.DisplayStackHeaders
            flux - array of flux values. [target_flux, target_sky_flux, ref0_flux, ...]
            skyFlux - array of sky flux values, scaled to same n_pix as object flux. [target_sky, ref0_sky, ...]
            flag - flag to indicate successful analysis. 0 is good
            apertureRad - same as input
            annulusInnerRad - same as input
            annulusOuterRad - same as input
            interpolation - same as input
            
            
        '''

        flux = []
        sky = []
        apRadOut = []
        annInOut = []
        annOutOut = []
        flag = 0

        #if sky fitting is selected for sky subtraction, do masking and produce polynomial sky image
        if sky_sub == "fit":
            warnings.warn("Sky fitting not well debugged. Use with extreme caution",UserWarning)
            skyIm = self.fitMaskedSky(self.image, aper_radius)

        if interpolation != None:
            if self.verbose:
                print "Performing %s interpolation on image"%interpolation
            try:
                interpImage = utils.interpolateImage(self.image, method=interpolation)
            except ValueError:
                interpImage = np.zeros(np.shape(self.image),dtype=float)
                print "Empty frame encountered on interpolation, filled with zeros"
            if self.showPlot:
                plotArray(title='Before interpolation', image=self.image)
                plotArray(title='After interpolation', image=interpImage)
        else:
            interpImage = self.image

        if self.showPlot:
            totalAngles = 100
            angleArray = np.linspace(0,2*np.pi,totalAngles)
            form=PopUp(title='Aperture photometry',showMe=False)
            form.plotArray(interpImage)

        #step through each star in centroid list: [target, ref0, ref1, ...]
        for star_i in range(len(self.centroid)):
                try: #check if different aperture radii are set for each star
                    radius=aper_radius[star_i]
                except TypeError:
                    radius=aper_radius

                try: #check if different annulus radii are set for each star
                    ann_in=annulus_inner[star_i]
                except TypeError:
                    ann_in=annulus_inner

                try: #check if different annulus radii are set for each star
                    ann_out=annulus_outer[star_i]
                except TypeError:
                    ann_out=annulus_outer

                objectFlux, nObjPix = self.getApertureCounts(interpImage,radius,self.centroid[star_i])
                if self.showPlot: #add aperture to output image if showPlot is true
                    form.axes.plot(self.centroid[star_i][0]+radius*np.cos(angleArray), self.centroid[star_i][1] + radius*np.sin(angleArray), 'b')

                if sky_sub == "fit":
                    skyFlux, nSkyPix = self.getApertureCounts(skyIm,radius,self.centroid[star_i])
                    ann_in = 0
                    ann_out = 0
                else:
                    skyFlux, nSkyPix = self.getAnnulusCounts(interpImage,ann_in,ann_out,self.centroid[star_i])
                    if self.showPlot: #add annulus to output image if showPlot is true
                        form.axes.plot(self.centroid[star_i][0]+ann_in*np.cos(angleArray), self.centroid[star_i][1] + ann_in*np.sin(angleArray), 'r')
                        form.axes.plot(self.centroid[star_i][0]+ann_out*np.cos(angleArray), self.centroid[star_i][1] + ann_out*np.sin(angleArray), 'r')
                flux.append(objectFlux)
                sky.append(skyFlux*(float(nObjPix)/float(nSkyPix)))

                #output radii used for aperture and annuli for bookkeeping
                apRadOut.append(radius)
                annInOut.append(ann_in)
                annOutOut.append(ann_out)

        if self.showPlot:
            form.show()

        return {'flux': np.asarray(flux), 'skyFlux': np.asarray(sky), 'apertureRad':np.asarray(apRadOut), 'annulusInnerRad':np.asarray(annInOut), 'annulusOuterRad':np.asarray(annOutOut), 'flag':flag, 'interpolation':interpolation}
stack = stackDict['stack']
wvls = stackDict['wvls']
fitImgList = []

for iFrame in range(0,np.shape(stack)[0]):
    frame = stack[iFrame,:,:]
    frame[frame>70] = 70

    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_title(wvls[iFrame])
    im = ax.matshow(frame, cmap = cm.get_cmap('rainbow'))
    fig.colorbar(im)
    #plt.show()

    intFrame = utils.interpolateImage(frame, 'linear')

    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_title(wvls[iFrame])
    im = ax.matshow(intFrame, cmap = cm.get_cmap('rainbow'))#, vmax = 40)
    fig.colorbar(im)
    plt.show()

    fitImgList.append(intFrame)

cube = np.array(fitImgList)
#np.savez(npzfitpsf,cube=cube,wvls=wvls)
print 'saved'
#utils.makeMovie(fitImgList,frameTitles=wvls, cbar=True, outName=giffitpsf, normMin=0, normMax=50)
 print fname
 stackFile = tables.openFile(fname, mode="r")
 stackNode = stackFile.root.stack
 stack = np.array(stackNode.stack.read())
 jd = np.array(stackNode.time.read()[0])
 stackFile.close()
 print "Stack length = ", np.shape(stack)
 print "JD length = ", np.shape(jd)
 for i in xrange(len(stack[0, 0, :])):
     print "Interpolating Frame ", i, " in stack"
     frame = stack[:, :, i]
     nanMask = np.isnan(frame)
     frame[nanMask] = 0.0
     imageStacks.append(frame)
     try:
         interpFrame = utils.interpolateImage(frame, method="linear")
     except ValueError:
         interpFrame = np.zeros(np.shape(frame), dtype=float)
         print "Empty frame encountered, filled with zeros"
     interpolatedStacks.append(interpFrame)
     times.append(jd[i])
     # inspect some interpolated frames
     """
     if i%20==0:
         fig = plt.figure()
         ax = fig.add_subplot(111)
         ax.set_title(jd[i])
         im = ax.matshow(frame, cmap = cm.get_cmap('rainbow'), vmax = 500)
         fig.colorbar(im)
         
         fig = plt.figure()