def plot_linefits(y, ff): global plot_arr pl.figure(3) pl.subplot(*plot_arr) ps = Fit.do_fit(y, Fit.residual_single)[0] xx = np.arange(len(y)) xxx = np.arange(0,len(y)-1,.1) fun = Fit.fit_single(ps,xxx) pl.plot(xx,y, '*') pl.plot(xxx, fun) x0 = ff(0) x1 = ff(0) + ps[4] pl.plot([x0, x0], [0, Fit.fit_single(ps, x0)]) pl.plot([x1, x1], [0, Fit.fit_single(ps, x1)]) pl.figure(4) pl.subplot(*plot_arr) fun = Fit.fit_single(ps,xx) r = (y - fun)/np.sqrt(np.abs(fun)) pl.plot(xx, r, '*') pl.ylim([-5,5])
def find_edge_pair(data, y, roi_width, edgeThreshold=450): ''' find_edge_pair finds the edge of a slit pair in a flat data[2048x2048]: a well illuminated flat field [DN] y: guess of slit edge position [pix] Keywords: edgeThreshold: the pixel value below which we should ignore using to calculate edges. Moves along the edge of a slit image - At each location along the slit edge, determines the position of the demarcations between two slits Outputs: xposs []: Array of x positions along the slit edge [pix] yposs []: The fitted y positions of the "top" edge of the slit [pix] widths []: The fitted delta from the top edge of the bottom [pix] scatters []: The amount of light between slits The procedure is as follows 1: starting from a guess spatial position (parameter y), march along the spectral direction in some chunk of pixels 2: At each spectral location, construct a cross cut across the spatial direction; select_roi is used for this. 3: Fit a two-sided error function Fit.residual_disjoint_pair on the vertical cross cut derived in step 2. 4: If the fit fails, store it in the missing list - else if the top fit is good, store the top values in top vector - else if the bottom fit is good, store the bottom values in bottom vector. 5: In the vertical cross-cut, there is a minimum value. This minimum value is stored as a measure of scattered light. Another procedure is used to fit polynomials to these fitted values. ''' def select_roi(data, roi_width): v = data[y - roi_width:y + roi_width, xp - 2:xp + 2] v = np.median(v, axis=1) # Axis = 1 is spatial direction return v xposs_top = [] yposs_top = [] xposs_top_missing = [] xposs_bot = [] yposs_bot = [] xposs_bot_missing = [] yposs_bot_scatters = [] #1 rng = np.linspace(10, 2040, 50).astype(np.int) for i in rng: xp = i #2 v = select_roi(data, roi_width) xs = np.arange(len(v)) # Modified from 450 as the hard coded threshold to one that # can be controlled by a keyword if (np.median(v) < edgeThreshold): xposs_top_missing.append(xp) xposs_bot_missing.append(xp) continue #3 ff = Fit.do_fit(v, residual_fun=Fit.residual_disjoint_pair) fit_ok = 0 < ff[4] < 4 if fit_ok: (sigma, offset, mult1, mult2, add, width) = ff[0] xposs_top.append(xp) yposs_top.append(y - roi_width + offset + width) xposs_bot.append(xp) yposs_bot.append(y - roi_width + offset) between = offset + width / 2 if 0 < between < len(v) - 1: start = np.max([0, between - 2]) stop = np.min([len(v), between + 2]) yposs_bot_scatters.append(np.min(v[start:stop])) # 5 if False: pl.figure(2) pl.clf() tmppix = np.arange(y - roi_width, y + roi_width) tmpx = np.arange(len(v)) pl.axvline(y - roi_width + offset + width, color='red') pl.axvline(y - roi_width + offset, color='red') pl.scatter(tmppix, v) pl.plot(tmppix, Fit.fit_disjoint_pair(ff[0], tmpx)) pl.axhline(yposs_bot_scatters[-1]) pl.draw() else: yposs_bot_scatters.append(np.nan) else: xposs_bot_missing.append(xp) xposs_top_missing.append(xp) info("Skipping wavelength pixel): %i" % (xp)) return map(np.array, (xposs_bot, xposs_bot_missing, yposs_bot, xposs_top, xposs_top_missing, yposs_top, yposs_bot_scatters))
def find_edge_pair(data, y, roi_width, edgeThreshold=450): ''' find_edge_pair finds the edge of a slit pair in a flat data[2048x2048]: a well illuminated flat field [DN] y: guess of slit edge position [pix] Keywords: edgeThreshold: the pixel value below which we should ignore using to calculate edges. Moves along the edge of a slit image - At each location along the slit edge, determines the position of the demarcations between two slits Outputs: xposs []: Array of x positions along the slit edge [pix] yposs []: The fitted y positions of the "top" edge of the slit [pix] widths []: The fitted delta from the top edge of the bottom [pix] scatters []: The amount of light between slits The procedure is as follows 1: starting from a guess spatial position (parameter y), march along the spectral direction in some chunk of pixels 2: At each spectral location, construct a cross cut across the spatial direction; select_roi is used for this. 3: Fit a two-sided error function Fit.residual_disjoint_pair on the vertical cross cut derived in step 2. 4: If the fit fails, store it in the missing list - else if the top fit is good, store the top values in top vector - else if the bottom fit is good, store the bottom values in bottom vector. 5: In the vertical cross-cut, there is a minimum value. This minimum value is stored as a measure of scattered light. Another procedure is used to fit polynomials to these fitted values. ''' def select_roi(data, roi_width): v = data[y-roi_width:y+roi_width, xp-2:xp+2] v = np.median(v, axis=1) # Axis = 1 is spatial direction return v xposs_top = [] yposs_top = [] xposs_top_missing = [] xposs_bot = [] yposs_bot = [] xposs_bot_missing = [] yposs_bot_scatters = [] #1 rng = np.linspace(10, 2040, 50).astype(np.int) for i in rng: xp = i #2 v = select_roi(data, roi_width) xs = np.arange(len(v)) # Modified from 450 as the hard coded threshold to one that # can be controlled by a keyword if (np.median(v) < edgeThreshold): xposs_top_missing.append(xp) xposs_bot_missing.append(xp) continue #3 ff = Fit.do_fit(v, residual_fun=Fit.residual_disjoint_pair) fit_ok = 0 < ff[4] < 4 if fit_ok: (sigma, offset, mult1, mult2, add, width) = ff[0] xposs_top.append(xp) yposs_top.append(y - roi_width + offset + width) xposs_bot.append(xp) yposs_bot.append(y - roi_width + offset) between = offset + width/2 if 0 < between < len(v)-1: start = np.max([0, between-2]) stop = np.min([len(v),between+2]) yposs_bot_scatters.append(np.min(v[start:stop])) # 5 if False: pl.figure(2) pl.clf() tmppix = np.arange(y-roi_width, y+roi_width) tmpx = np.arange(len(v)) pl.axvline(y - roi_width + offset + width, color='red') pl.axvline(y - roi_width + offset, color='red') pl.scatter(tmppix, v) pl.plot(tmppix, Fit.fit_disjoint_pair(ff[0], tmpx)) pl.axhline(yposs_bot_scatters[-1]) pl.draw() else: yposs_bot_scatters.append(np.nan) else: xposs_bot_missing.append(xp) xposs_top_missing.append(xp) info("Skipping wavelength pixel): %i" % (xp)) return map(np.array, (xposs_bot, xposs_bot_missing, yposs_bot, xposs_top, xposs_top_missing, yposs_top, yposs_bot_scatters))
def go(fname): global plot_arr print fname (header, data) = IO.readfits(fname) bs = CSU.Barset() bs.set_header(header) bars = [] means = [] sds = [] deltas = [] deltas_mm = [] poss = [] poss_mm = [] poss_y = [] request = [] qs = [] bars = range(1, 93) fit_fun = Fit.residual_single for bar in bars: pos = bs.get_bar_pix(bar) if bar % 8 == 0: print "%2.0i: (%7.2f, %7.2f)" % (bar, pos[0], pos[1]) if is_odd(bar): if (bs.pos[bar] - bs.pos[bar-1]) < 2.7: fit_fun = Fit.residual_pair else: fit_fun = Fit.residual_single width = 19 [[xslice, yslice],extent,ystart] = make_slice(pos,0,width,30) if not is_in_bounds(extent): fits = [0,0,0,0,0] [ff,ok] = [np.poly1d(0,0), []] means.append(fits) sds.append(fits) drop_this = True else: drop_this = False fits = [] ys = np.arange(-10,10, dtype=np.float32) for i in ys: tofit = data[ystart-i, xslice] y = median_tails(tofit) ps = Fit.do_fit(y, fit_fun) fits.append(ps[0]) fits = np.array(fits) fits[:,1] += 1 # fit to the ridgeline [ff, ok] = fit_line_with_sigclip(ys, fits[:,1]) m = [np.mean(fits[:,i]) for i in range(5)] s = [np.std(fits[:,i]) for i in range(5)] means.append(m) sds.append(s) slit_center_offset = pos[1] - ystart fc = ff(slit_center_offset) slit_center_pos = np.float(extent[0] + fc ) if drop_this: poss.append(NaN) poss_y.append(NaN) poss_mm.append(NaN) else: poss.append(slit_center_pos) poss_y.append(ystart) poss_mm.append(CSU.csu_pix_to_mm_poly(slit_center_pos, ystart)[0]) delta = np.float(slit_center_pos - pos[0]) if drop_this: deltas.append(NaN) deltas_mm.append(NaN) else: deltas.append(delta) b = CSU.csu_pix_to_mm_poly(slit_center_pos + delta, ystart)[0] deltas_mm.append(b - poss_mm[-1]) q = np.float(np.degrees(np.tan(ff(1)-ff(0)))) if drop_this: qs.append(NaN) qs.append(q) means = np.array(means) f = lambda x: np.array(x).ravel() sds = f(sds) deltas = f(deltas) poss = f(poss) poss_y = f(poss_y) poss_mm = f(poss_mm) deltas_mm = f(deltas_mm) qs = f(qs) bars = f(bars) fout = "/users/npk/dropbox/mosfire/cooldown 9/csu_meas/" + fname.split("/")[-1] + ".sav" print "saving" tosav = {"bars": bars, "request": bs.pos, "deltas_mm": deltas_mm, "poss": poss, "poss_mm": poss_mm, "deltas": deltas, "means": means, "qs": qs} scipy.io.savemat(fout, tosav) save_region(bs, "/users/npk/dropbox/mosfire/cooldown 9/csu_meas/" + fname.split("/")[-1] + ".reg") print "saved" regout = "/users/npk/dropbox/mosfire/cooldown 9/csu_meas/" + fname.split("/")[-1] + ".meas.reg" pairs = np.array([poss,poss_y]).transpose() s = CSU.to_ds9_region(pairs, dash=0, color="blue", label=False) try: f = open(regout, "w") f.writelines(s) f.close() except: print "Couldn't write: %s" % regout return [tosav, bs]
[[xslice, yslice], extent] = make_slice(pos, 6, 25) if extent[0] == extent[1]: cnt += 1 continue if extent[2] == extent[3]: cnt += 1 continue cnt += 1 fits = [] xs = np.arange(-10, 10) for i in xs: tofit = data[pos[1] - i, xslice] y = median_tails(tofit) ps = Fit.do_fit(y, Fit.residual_pair) fits.append(ps[0]) fits = np.array(fits) m = [np.mean(fits[:, i]) for i in range(5)] s = [np.std(fits[:, i]) for i in range(5)] means.append(m) sds.append(s) [ff, ok] = fit_line_with_sigclip(xs, fits[:, 1]) pl.figure(5) pl.subplot(7, 7, cntfit) pl.plot(xs, fits[:, 1] - ff(xs), '*-') pl.plot(xs[ok], fits[ok, 1] - ff(xs[ok]), 'or-')
def go(fname): global plot_arr print fname (header, data) = IO.readfits(fname) bs = CSU.Barset() bs.set_header(header) cntfit = 1 for i in range(1,8): continue pl.figure(i) pl.clf() first_time = True bars = [] means = [] sds = [] deltas = [] deltas_mm = [] poss = [] poss_mm = [] poss_y = [] request = [] qs = [] bars = range(1, 93) for bar in bars: pos = bs.get_bar_pix(bar) if bar % 8 == 0: print "%2.0i: (%7.2f, %7.2f)" % (bar, pos[0], pos[1]) width = 19 [[xslice, yslice],extent,ystart] = make_slice(pos,0,width,30) if not is_in_bounds(extent): fits = [0,0,0,0,0] [ff,ok] = [np.poly1d(0,0), []] means.append(fits) sds.append(fits) drop_this = True else: drop_this = False fits = [] ys = np.arange(-10,10, dtype=np.float32) for i in ys: tofit = data[ystart-i, xslice] y = median_tails(tofit) ps = Fit.do_fit(y, Fit.residual_single) fits.append(ps[0]) fits = np.array(fits) fits[:,1] += 1 # fit to the ridgeline [ff, ok] = fit_line_with_sigclip(ys, fits[:,1]) m = [np.mean(fits[:,i]) for i in range(5)] s = [np.std(fits[:,i]) for i in range(5)] means.append(m) sds.append(s) #if bar == 44: start_shell() #if bar == 43: start_shell() # End of measurement logic, PLOTS plot_arr = [12, 8, cntfit] cntfit += 1 if False: plot_stamps(data[yslice, xslice], ps[0]) y0 = median_tails(data[ystart, xslice]) plot_linefits(y0, ff) plot_ridgeline(fits, ok, ys, ff, bar) plot_widths(fits, ok, ys) # End of plots, BOOKEEPING slit_center_offset = pos[1] - ystart fc = ff(slit_center_offset) slit_center_pos = np.float(extent[0] + fc ) if drop_this: poss.append(NaN) poss_y.append(NaN) poss_mm.append(NaN) else: poss.append(slit_center_pos) poss_y.append(ystart) poss_mm.append(CSU.csu_pix_to_mm_poly(slit_center_pos, ystart)[0]) delta = np.float(slit_center_pos - pos[0]) if drop_this: deltas.append(NaN) deltas_mm.append(NaN) else: deltas.append(delta) b = CSU.csu_pix_to_mm_poly(slit_center_pos + delta, ystart)[0] deltas_mm.append(b - poss_mm[-1]) q = np.float(np.degrees(np.tan(ff(1)-ff(0)))) if drop_this: qs.append(NaN) qs.append(q) if False: #is_in_bounds(extent): pl.figure(2) pl.text(pos[0], pos[1], 'b%2.0i: w=%3.2f p=%5.2f q=%3.2f d=%1.3f' % (bar, np.mean(fits[:,4]), extent[0]+ff(0), q, delta), fontsize=11, family='monospace', horizontalalignment='center') means = np.array(means) f = lambda x: np.array(x).ravel() sds = f(sds) deltas = f(deltas) poss = f(poss) poss_y = f(poss_y) poss_mm = f(poss_mm) deltas_mm = f(deltas_mm) qs = f(qs) bars = f(bars) pl.draw() if False: [pf, ok] = fit_line_with_sigclip(bars, deltas) print "** Residual: %4.3f [pix]" % np.std(deltas[ok]-pf(bars[ok])) evens = range(0,92,2) odds = range(1,92,2) pl.plot(bars[evens], deltas[evens],'r*-') pl.plot(bars[odds], deltas[odds],'b*-') pl.title("Red: even, blue: odd") pl.xlabel("Bar #") pl.ylabel("Delta pixel (Measured - Predicted)") pl.plot(bars, pf(bars)) fout = "/users/npk/dropbox/mosfire/cooldown 9/csu_meas/" + fname.split("/")[-1] + ".sav" print "saving" tosav = {"bars": bars, "request": bs.pos, "deltas_mm": deltas_mm, "poss": poss, "poss_mm": poss_mm, "deltas": deltas, "means": means, "qs": qs} scipy.io.savemat(fout, tosav) save_region(bs, "/users/npk/dropbox/mosfire/cooldown 9/csu_meas/" + fname.split("/")[-1] + ".reg") print "saved" regout = "/users/npk/dropbox/mosfire/cooldown 9/csu_meas/" + fname.split("/")[-1] + ".meas.reg" pairs = np.array([poss,poss_y]).transpose() s = CSU.to_ds9_region(pairs, dash=0, color="blue", label=False) try: f = open(regout, "w") f.writelines(s) f.close() except: print "Couldn't write: %s" % regout return [tosav, bs]
[[xslice, yslice],extent] = make_slice(pos, 6,25) if extent[0] == extent[1]: cnt += 1 continue if extent[2] == extent[3]: cnt += 1 continue cnt+=1 fits = [] xs = np.arange(-10,10) for i in xs: tofit = data[pos[1]-i, xslice] y = median_tails(tofit) ps = Fit.do_fit(y, Fit.residual_pair) fits.append(ps[0]) fits = np.array(fits) m = [np.mean(fits[:,i]) for i in range(5)] s = [np.std(fits[:,i]) for i in range(5)] means.append(m) sds.append(s) [ff, ok] = fit_line_with_sigclip(xs, fits[:,1]) pl.figure(5) pl.subplot(7,7,cntfit) pl.plot(xs, fits[:,1] - ff(xs), '*-') pl.plot(xs[ok], fits[ok,1] - ff(xs[ok]), 'or-')
print "-------------==========================------------------" print "Finding Slit Edges for %s starting at %4.0i" % (ssl[target]["Target_Name"], y) tock = time.clock() yposs = [] widths = [] xposs = [] x = 936 for i in range(-49, 50): delt = 1900/100. xp = x+delt*i v = data[y-roi_width:y+roi_width, xp-2:xp+2] v = np.median(v, axis=1) ff = Fit.do_fit(v, residual_fun=Fit.residual_disjoint_pair) if (0 < ff[4] < 4): xposs.append(x+delt*i) xs = np.arange(len(v)) yposs.append(ff[0][1] - roi_width) widths.append(ff[0][5]) else: print "Skipping: %i" % (x+delt*i) (xposs, yposs, widths) = map(np.array, (xposs, yposs, widths)) fun = np.poly1d(Fit.polyfit_clip(xposs, yposs, 3)) wfun = np.poly1d(Fit.polyfit_clip(xposs, widths, 3)) res = fun(xposs) - yposs sd = np.std(res)