def make_iraf_slicemap(filename, N, savename=None):
if len(filename) + len('[*,*,]') + len(str(N)) > 23:
warn('Filenames + slice is larger that 23 characters! ==> IRAF will truncate theses '
'filenames when writing to database. YES, IRAF SUCKS!!!' )
slicemap = lambda i: '%s[*,*,%i]'%(filename, i)
slices =list( map(slicemap, range(1,N+1)) )
if not savename is None:
np.savetxt( str(savename), slices, fmt='%s' )
return list(slices)
def WindowOutlierDetection(data, nwindow, noverlap, method, weight_kernel=None,
return_index=True, return_mask=False, return_masked_data=False,
*args, **kwargs): #recur=None
noverlap = Spectral.get_overlap(nwindow, noverlap)
N = data.shape[-1]
if N<nwindow:
warn( 'Data length smaller than window size! No clipping done!')
return data.mask
step = nwindow - noverlap
noc = Div.get_nocc(N, nwindow, noverlap)
if weight_kernel is None:
weight_kernel = 'boxcar'
weights = get_window( weight_kernel, nwindow )
S = defaultdict(int)
#q = Div.div(data, nwindow, noverlap)
#if data.ndim>1:
#q = q.transpose(1,0,2) #swap the axes around so we can enumerate easily
#if np.ma.is_masked(data):
#embed()
for i, dat in enumerate( Div.div(data, nwindow, noverlap) ):
widx = method(dat.T, *args, **kwargs) #indeces of outliers relative to this window
if len(widx):
didx = i*step + np.array(widx) #indeces relative to data
didx = didx[didx<N] #remove indeces that exceed array dimensions
for ii,jj in zip(widx, didx):
S[jj] += weights[ii] / noc[jj] #mean probability that points where flagged as outliers
IDX = np.sort( [idx for idx,p in S.items() if p>0.5] )
if return_index:
return IDX
if return_mask:
mask = np.zeros(data.shape, bool)
if len(IDX):
mask[IDX] = True
return mask
if return_masked_data:
if np.ma.isMA(data):
data.mask[IDX] = True
else:
mask = np.zeros_like(data, bool)
mask[IDX] = True
data = np.ma.masked_where(mask, data)
return data
def __init__(self, data, title=None, title_props=(),
col_headers=None, col_head_props='bold', col_widths=None, col_borders='|', col_sort=None,
row_headers=None, row_head_props='bold', where_row_borders=None, row_sort=None,
align='left', num_prec=2, enumera=False,
ignore_keys=None ):
'''
Class to create and optionally colourise tabular representation of data for terminal output.
Parameters
----------
data : input data - must be 1D, 2D or dict
if dict, keys will be used as row_headers, and values as data
title : The table title
title_props : str, tuple or dict with ANSICodes property descriptors
col_headers : column headers.
col_head_props : str, tuple or dict with ANSICodes property descriptors to use as global column header properties
TODO: OR a sequence of these, one for each column
col_widths : numerical column width
col_borders : character used as column seperator
col_sort : TODO callable that operates on strings and returns column sorting order
row_headers :
row_head_props : see col_head_props
where_row_borders: sequence with row numbers below which a solid border will be drawn.
Default is after column headers and after last line
row_sort : TODO callable that operates on strings and returns row sorting order
align : column alignment - ('left', 'right', or 'center')
num_prec : integer precision to use for number representation FIXME!!!!!!!!!!!!!
enumera : bool
Will number the rows if True
ignore_keys : if dictionary is passed as data, optionally specify the keys that will not be printed in table
'''
#self.datatypes = np.vectorize(type)(data)
self.original_data = data
if isinstance(data, dict):
if not row_headers is None:
warn( "Dictionary keys will be superceded by 'row_headers'." )
row_headers, data = self.convert_dict( data, ignore_keys )
#convert to array of SuperStrings
self.data = as_superstrings( data )
#check data shape
dim = np.ndim(self.data)
if dim == 1:
self.data = self.data[None].T #default for 1D data is to display in a column with row_headers
if dim > 2:
raise ValueError( 'Only 2D data can be tabelised! Data is {}D'.format(dim) )
#title
self.title = title
self.title_props = title_props
self.enumera = enumera
#row and column headers
self.has_row_head = not row_headers is None
self.has_col_head = not col_headers is None
if self.has_col_head:
self.col_headers = self.apply_props(col_headers, col_head_props)
if self.has_col_head and self.has_row_head:
#TODO: when both are given, the 0,0 table position is ambiguously both column and row header
#TODO: allow user to specify either
if len(row_headers) == self.data.shape[0]:
row_headers = [''] + list(row_headers)
if self.has_row_head:
Nrows = len(row_headers)
self.row_headers = self.apply_props(row_headers, row_head_props).reshape(Nrows,1)
self.pre_table = self.add_headers()
Nrows, Ncols = self.pre_table.shape
#Column specs
if col_widths is None:
self.col_widths = np.vectorize(len)( self.pre_table ).max(axis=0) + 1
self.col_widths_no_ansi = np.vectorize(SuperString.len_no_ansi)( self.pre_table ).max(axis=0) + 1
else:
self.col_widths = col_widths
self.col_borders = col_borders
#column alignment
almap = { 'r' : '>', 'l' : '<', 'c' : '^' } #map to alignment characters
if align.lower()[0] in almap:
self.align = almap[ align.lower()[0] ]
else:
raise ValueError( 'Unrecognised alignment {!r}'.format(align) )
#The column format specification. 0 - item; 1 - fill; 2 - alignment character
self.col_fmt = '{0:{2}{1}}'
self.num_prec = num_prec
#Row specs
self.rows = []
self.row_fmt = ('{}'+self.col_borders) * Ncols
if where_row_borders:
self.where_row_borders = where_row_borders
else:
if self.has_col_head:
self.where_row_borders = [0, Nrows-1]
else:
self.where_row_borders = [Nrows-1]
def load_image(self, filename=None, data=None, **kw):
"""
Load the image for display, applying IRAF's zscale algorithm for colour limits.
"""
print("Loading image {}".format(filename))
##### Load the image #####
if filename and data is None:
self.filename = filename
FF = FITSFrame(filename)
self.image_data = data = FF[1]
self.image_header = FF.master_header
# get readout noise and saturation if available
self.ron = self.image_header.get("ron")
try: # Only works for SHOC data
self.saturation = RNT.get_saturation(
filename
) # NOTE: THIS MEANS RNT NEEDS TO BE INSTANTIATED BEFORE StarSelector!!!!!!!!
except Exception as err:
warn("Error in retrieving saturation value:\n" + str(err))
self.saturation = "INDEF"
elif not data is None:
self.image_data = data
self.ron = self.saturation = None
else:
raise ValueError("Please provide either a FITS filename, or the actual data")
# if kw.get( 'fliplr' , False ):
if self.image_header["flipx"]:
data = np.fliplr(data)
# if WCS: data = np.fliplr( data )
self.image_data_cleaned = data.copy()
r, c = self.image_shape = data.shape
self.pixels = np.mgrid[:r, :c] # the pixel grid
##### Plot star field #####
# zilms = zrange(data, sigma_clip=5., maxiter=5, contrast=1./99)
zlims = np.percentile(data, (0.25, 99.75))
fig, ax = self.figure, self.ax
self.canvas = self.figure.canvas
self.image = ax.imshow(data, origin="lower", cmap="gist_heat", vmin=zlims[0], vmax=zlims[1]) # gist_earth, hot
# ax.set_title( 'PSF Measure' )
# TODO: #PRINT TARGET NAME AND COORDINATES ON IMAGE!! DATE, TIME, ETC.....
# TODO: Axes Sliders
# TODO: Tight colourbar + switchable maps
self.colour_bar = fig.colorbar(self.image, ax=ax)
# self.stars.zlims = zlims
# box = ax.get_position()
# ax.set_position([box.x0, box.y0 + box.height * 0.1,
# box.width, box.height * 0.9])
# create the canvas backgrounds for blitting
# canvas = FigureCanvas(self.figure)
# self.backgrounds = [canvas.copy_from_bbox( ax.bbox ) for ax in fig.axes]
self.snap = Snapper(
self.image_data_cleaned,
window=self.window,
snap="peak",
edge="shift",
noise_threshold=2.5,
offset_tolerance=3,
)
self.psf = self.PSFClass()
self.fit = StarFit(self.psf, hints=False)
self.fitplotter = psfPlotFactory(self.plot_fits)()
##### Add ApertureCollection to axes #####
self.stars = Stars(self.idx, window=self.window)
self.stars.axadd(ax)
# initialize model plots
self.stars.model.init_plots(fig)
