def peak2halo(files,exten=None,image=None):
if (image is not None):
im = image
xcen = 0.0
ycen = 0.0
ratio = 0.0
nfiles = 1
else:
if isinstance(files,(tuple,list)):
nfiles = size(files)
else:
nfiles = 1
files = [files]
xcen = np.empty(nfiles,dtype=float)
ycen = np.empty(nfiles,dtype=float)
ratio = np.empty(nfiles,dtype=float)
if exten is None: exten = 1
if exten != 1 and exten != 2 :
print 'the EXTEN keyword must be equal to 1 OR 2.'
return
k = 0
for nfic in range(nfiles):
#print 'peak2halo ['+str(nfic+1)+'/'+str(nfiles)+']'
if (image is None):
hdr = pf.getheader(files[nfic])
if hdr['instrume']!='NICI':
print files[nfic],' is not NICI file. Skip it'
return
#continue
elif hdr['obsclass']!= 'science':
print files[nfic],' is not NICI science file. Skip it'
return
#continue
im = pf.getdata(files[nfic],exten)
# reads the fits image. We will measure the peak/halo
# ratio only in the extension=exten
bin = medbin(im,32,32)
# # calculates de std inside
#dev = bin[5:27,5:27].std()
#bin = bin[5:27,5:27] - np.median(bin[5:27,5:27])
## see if we have a mask in the frame
#nelem_mask = np.size(np.where(abs(bin)>dev*5))/2
#if nelem_mask == 0:
# return -99,-1,-1
im = congrid( (bin > 3*robust_sigma(bin))*1 ,(1024,1024))*im
px = np.zeros(1024,dtype=float)
py = np.zeros(1024,dtype=float)
for i in range(64):
py = np.clip(py,\
np.nan_to_num(np.median(im[:,i*16:i*16+16],axis=1)),np.amax(py))
for i in range(64):
px = np.clip(px, \
np.nan_to_num(np.median(im[i*16:i*16+16,:],axis=0)),np.amax(px))
# extract the maximum value seen in the image for a
# 16 pixel-wide stripe- in the x and y direction
px = np.clip(px,min(px),max(px)*.25)
py = np.clip(py,min(py),max(py)*.25)
offset = 1023 - np.arange(2047.)
# cross-correlate this profile with a 'flipped' version
# of itself. A peak at pixel 512 will have a '0' offset
xrr = size(px) - np.arange(size(px))-1
cx = c_correlate(px,px[xrr],offset)
# a peak at pixel N will have a 2*(512-N) offset
cy = c_correlate(py,py[size(py)-np.arange(size(py))-1],offset)
ix = cx.argmax()
xcen_tmp0 = 512-offset[ix]/2.
iy = cy.argmax()
ycen_tmp0 = 512-offset[iy]/2. # derive the position of the peakmax
# get a fine centroid at this position
medfilter = medfilt2d(im,7)
tmp=(im-medfilter)[ycen_tmp0-20:ycen_tmp0+20,xcen_tmp0-20:xcen_tmp0+20]
try:
id = tmp.argmax()
xcen_tmp0 += ((id%40)-20)
ycen_tmp0 += (id/40-20)
xcen_tmp,ycen_tmp = gcentroid(im,xcen_tmp0,ycen_tmp0,9)
except:
xcen_tmp = -1
if xcen_tmp < 0:
peak=-1; halo=1
break
if mt.sqrt((xcen_tmp0-xcen_tmp)**2+(ycen_tmp0-ycen_tmp)**2) > 9:
peak=-1; halo=1
break
xc = round(xcen_tmp)
yc = round(ycen_tmp)
#x = np.arange(xc-3,xc+4)
#y = np.arange(yc-3,yc+4)
#z = im[yc-3:yc+4,xc-3:xc+4]
x = np.arange(xcen_tmp-2,xcen_tmp+5)
y = np.arange(ycen_tmp-2,ycen_tmp+5)
z = im[yc-2:yc+5,xc-2:xc+5]
try:
pxy = interp2d(x,y,z,kind='cubic')
peak = float(pxy(xcen_tmp,ycen_tmp))
except:
peak =-1; halo=1
break
# get an accurate estimate of the peak value
r = dist_circle([1024,1024],xcen=xcen_tmp,ycen=ycen_tmp)
g = np.where((r > 20) & (r < 30))
# get the median value between 20 and 30 pixels of this peak
halo = np.median(im[g])
if nfiles > 1:
ratio[k] = peak/halo
xcen[k] = xcen_tmp
ycen[k] = ycen_tmp
else:
if xcen_tmp < 0:
ratio = -1
else: ratio = peak/halo
xcen = xcen_tmp
ycen = ycen_tmp
return ratio,np.float(xcen_tmp),np.float(ycen_tmp)
k += 1
if (nfiles == 1):
if xcen_tmp < 0:
ratio = -1
xcen = -1; ycen = -1
else:
ratio = peak/halo
xcen = np.float(xcen_tmp)
ycen = np.float(ycen_tmp)
return ratio,xcen,ycen
def medfilter(self):
clobber = self.clobber
gphu = self.gphu
odir = self.odir
suffix = self.suffix
log = self.log
#self._get_filters_scaling(self.idir+self.inputs[0])
if self._file_exists('','cube_sdi'): return
l1 = self.l1
l2 = self.l2
rcube = self._read_fits('red','cube')
bcube = self._read_fits('blue','cube')
#rcube = self.cubes['red']
#bcube = self.cubes['blue']
sz = np.shape(rcube)
if not self.central: # r is a 2d image with pixel values
r = dist_circle([1024,1024]) # corresponding to the distance to the
else: # center of the image
r = dist_circle([512,512])
# Find pixels between 25 and 50 pixels from the center of the image.
# These values should be modified when using a mask other than 0.32''
g = np.where((r > 25) & (r < 50))
# The masks data is: Scale is 0.018 ''/pixels
#Focal Plane Mask keyword name: FPMW
# Values are:
# Clear
# 0.90 arcsec
# 0.65 arcsec
# 0.46 arcsec
# 0.32 arcsec radious 18 pixels
# 0.22 arcsec
# Grid
# User
rad = np.zeros(round(np.amax(r))-10,dtype=np.float32)
cube_diff = np.zeros(np.shape(rcube),dtype=np.float32)
# Scale rcube or bcube to the shorther wlen (depends on the set
# of filter used)
scale = min(l1,l2)/l1
fn = 0
if scale == 1.0:
scale = min(l1,l2)/l2
fn = 1
ft = lambda i,o: '%.2f %d:%.2d' % (time.time()-i,(time.time()-o)/60,(time.time()-o)%60)
to = time.time()
for i in range(sz[0]):
ti = time.time()
rim = self._medfilter(rcube[i,:,:],r,rad)
bim = self._medfilter(bcube[i,:,:],r,rad)
log.info('medfilter: ['+str(i+1)+'/'+str(sz[0])+'] ' + ft(ti,to))
rcube[i,:,:] = rim
bcube[i,:,:] = bim
# scale r or b
ti = time.time()
sim = self._scale_im((rim,bim)[fn],scale)
log.info('scale: ' +ft(ti,to))
ti = time.time()
cube_diff[i,:,:] = self._sdi(((sim,bim),(rim,sim))[fn],self.pa[i],g)
log.info('sdi (red-blue): ' +ft(ti,to))
self._write_fits(cube_diff,'','cube_sdi')
self._write_fits(np.median(cube_diff,axis=0),'','sdi_medcrunch')
self._write_fits(rcube,'red','cube_medfilter')
self._write_fits(bcube,'blue','cube_medfilter')
self._shift_medfilter(rcube,'red')
self._shift_medfilter(bcube,'blue')
rcube = self._rotate_cube(rcube)
bcube = self._rotate_cube(bcube)
self._write_fits(np.median(rcube,axis=0),'red','medfilter_medcrunch_rotate')
self._write_fits(np.median(bcube,axis=0),'blue','medfilter_medcrunch_rotate')
# Release memory
del rcube,bcube,cube_diff
