def getFeatures(self): features = [] # Preprocess the ch1 image -- let's just try an abs img = self.ch1 hist, bins = np.histogram(img.ravel(), 256, [0, np.max(img)]) #plt.hist(img.ravel(),256,[0,np.max(img)]); plt.show() zero = np.argmax(hist) img = img - bins[zero] ch1 = np.abs(img) ch1 = ndimage.gaussian_filter(ch1, sigma=2) ch6 = self.ch6 ch6 = ndimage.gaussian_filter(ch6, sigma=2) features = np.concatenate([features, gaussfitter.gaussfit(ch1)]) features = np.concatenate([features, gaussfitter.gaussfit(ch6)]) return features
def test_masked_fit(self): inpars = [0, 1, 64, 64, 8, 8, 0] in_data = gf.twodgaussian(inpars, shape=(128, 128)) masked_data = np.ma.array(in_data) # fit should be independent of masked data value masked_data[64, 64] = 1e6 masked_data[64, 64] = np.ma.masked fit1 = gf.gaussfit(masked_data) masked_data[64, 64] = 0 masked_data[64, 64] = np.ma.masked fit2 = gf.gaussfit(masked_data) for v1, v2 in zip(fit1, fit2): self.assertAlmostEqual(v1, v2)
def test_masked_fit(self): inpars = [0, 1, 64, 64, 8, 8] in_data = gf.twodgaussian(inpars, shape=(128,128), rotate=False) masked_data = np.ma.array(in_data) # fit should be independent of masked data value masked_data[64,64] = 1e6 masked_data[64,64] = np.ma.masked fit1 = gf.gaussfit(masked_data, rotate=False) masked_data[64,64] = 0 masked_data[64,64] = np.ma.masked fit2 = gf.gaussfit(masked_data, rotate=False) for v1, v2 in zip(fit1, fit2): self.assertAlmostEqual(v1, v2)
def test_simple_fit(self): # fit a 2D gaussian function centered at (64, 64) with width 8 # inpars = [height,amplitude,center_x,center_y,width_x,width_y,rota] inpars = [0, 1, 64, 64, 8, 8,] in_data = gf.twodgaussian(inpars, shape=(128, 128), rotate=False) fit = gf.gaussfit(in_data, rotate=False) for inval, outval in zip(inpars, fit): self.assertAlmostEqual(inval, outval)
def test_simple_fit(self): # fit a 2D gaussian function centered at (64, 64) with width 8 # inpars = [height,amplitude,center_x,center_y,width_x,width_y,rota] inpars = [0, 1, 64, 64, 8, 8, 0] in_data = gf.twodgaussian(inpars, shape=(128, 128)) fit = gf.gaussfit(in_data) for inval, outval in zip(inpars, fit): self.assertAlmostEqual(inval, outval)
def getfit(frame): if np.max(frame) != np.max(np.abs(frame)): onoroff = -1 else: onoroff = 1 pars = gfit.gaussfit(frame * onoroff) f = gfit.twodgaussian(pars) return f, pars, onoroff
def __call__(self, im): kernel = self.reference[::-1, ::-1] cor = fftconvolve(im, kernel, mode='same') y, x = find_max_star(cor) g = gaussfit(cor[max(0, y - 40):min(y + 40, cor.shape[0]), max(0, x - 40):min(x + 40, cor.shape[1])]) shiftx = np.rint(cor.shape[1] / 2.) - max(0, x - 40) - g[2] shifty = np.rint(cor.shape[0] / 2.) - max(0, y - 40) - g[3] #shifts.append((shifty,shiftx)) return (shifty, shiftx)
def shift_est(psf_stack): """Estimates shifts (see SPRITE paper, section 3.4.1., subsection 'Subpixel shifts'). Calls: * gaussfitter.gaussfit * :func:`utils.compute_centroid` """ shap = psf_stack.shape U = zeros((shap[2],2)) param=gaussfitter.gaussfit(psf_stack[:,:,0],returnfitimage=False) #(centroid_ref,Wc) = compute_centroid(psf_stack[:,:,0],(param[3]+param[4])/2) centroid_out = zeros((shap[2],2)) for i in range(0,shap[2]): param=gaussfitter.gaussfit(psf_stack[:,:,i],returnfitimage=False) (centroid,Wc) = compute_centroid(psf_stack[:,:,i],(param[3]+param[4])/2) U[i,0] = centroid[0,0]-double(shap[0])/2 U[i,1] = centroid[0,1]-double(shap[1])/2 centroid_out[i,0] = centroid[0,0] centroid_out[i,1] = centroid[0,1] return U,centroid_out
def shift_est(psf_stack): """Estimates shifts (see SPRITE paper, section 3.4.1., subsection 'Subpixel shifts'). Calls: * gaussfitter.gaussfit * :func:`utils.compute_centroid` """ shap = psf_stack.shape U = zeros((shap[2], 2)) param = gaussfitter.gaussfit(psf_stack[:, :, 0], returnfitimage=False) #(centroid_ref,Wc) = compute_centroid(psf_stack[:,:,0],(param[3]+param[4])/2) centroid_out = zeros((shap[2], 2)) for i in range(0, shap[2]): param = gaussfitter.gaussfit(psf_stack[:, :, i], returnfitimage=False) (centroid, Wc) = compute_centroid(psf_stack[:, :, i], (param[3] + param[4]) / 2) U[i, 0] = centroid[0, 0] - double(shap[0]) / 2 U[i, 1] = centroid[0, 1] - double(shap[1]) / 2 centroid_out[i, 0] = centroid[0, 0] centroid_out[i, 1] = centroid[0, 1] return U, centroid_out
def gaussfit2d(self,img,returnfitimage=True,return_all=False): """ 2d gaussian params: (height, amplitude, center_x, center_y, width_x, width_y, theta) """ x_dim,y_dim = img.shape limitedmin = [False,False,True,True,True,True,True] limitedmax = [False,False,True,True,True,True,True] minpars = [0.0, 0.0, 0, 0, x_dim*0.1, y_dim*0.1, 0.0] maxpars = [0.0, 0.0, x_dim, y_dim, x_dim*0.8, y_dim*0.8, 360.0] usemoment= np.array([True,True,False,False,False,False,True],dtype='bool') #usemoment=np.array([],dtype='bool') params = [0.0, 0.0, x_dim/2, y_dim/2, x_dim/3, y_dim/3, 0.0] img = nd.filters.gaussian_filter(img,0.2) if returnfitimage: params,img = gaussfit(img,params=params,returnfitimage=True,limitedmin=limitedmin,\ limitedmax=limitedmax,minpars=minpars,maxpars=maxpars,usemoment=usemoment) return params,img elif return_all: params,errors = gaussfit(img,params=params,return_all=True,limitedmin=limitedmin,\ limitedmax=limitedmax,minpars=minpars,maxpars=maxpars,usemoment=usemoment) return params,errors
def gaussBoxFit(img, outLength): # ~ Given an image and extent from the central pixel, finds the brightest point and then returns the parameters of a gaussian curve fit to those bbout = findBrightBox(img, outLength) pixSet = bbout[0] sideLength = (outLength * 2) + 1 if checkOnePeak(pixSet) == True: xes = np.arange((outLength * 2) + 1) bits = gaussfit((pixSet), return_error='True', circle='True') #drawGaussCircle(image, (bbout[2]+bits[0][2], bbout[1]+bits[0][3]), bits[0][4]) return (bits) else: return ([np.zeros(5), np.zeros(5)])
def gaborfit(data,err=None,params=(),fixed=np.repeat(False,9), limitedmin=[False,False,False,False,True,True,True,True,True], limitedmax=[False,False,False,False,False,False,True,False,True], minpars=[0.0, 0.0, 0.0, 0.0, 0.01, 0.01, 0.0, 0.01, 0.0], maxpars=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 360.0, 0.0, 360.0], quiet=True,returnmp=False,return_all=False,returnfitimage=False,**kwargs): """ gabor params = (height,amplitude,center_x,center_y,width_x,width_y,theta,lambda,phi) """ """ gaussian params=(height, amplitude, center_x, center_y, width_x, width_y, theta) """ if len(params) == 0: params,_errors = gaussfit(data,limitedmin=limitedmin[:7],limitedmax=limitedmax[:7],\ minpars=minpars[:7],maxpars=maxpars[:7],return_all=True) spatial_freq = math.sqrt(params[2]**2+params[3]**2) phase = 0.0 params = np.append(params, np.array([spatial_freq, phase],dtype='float')) def mpfitfun(data,err): if err is None: def f(p,fjac=None): return [0,np.ravel(data-twodgabor(p)\ (*np.indices(data.shape)))] else: def f(p,fjac=None): return [0,np.ravel((data-twodgabor(p)\ (*np.indices(data.shape)))/err)] return f parinfo = [ {'n':0,'value':params[0],'limits':[minpars[0],maxpars[0]],'limited':[limitedmin[0],limitedmax[0]],'fixed':fixed[0],'parname':"HEIGHT",'error':0}, {'n':1,'value':params[1],'limits':[minpars[1],maxpars[1]],'limited':[limitedmin[1],limitedmax[1]],'fixed':fixed[1],'parname':"AMPLITUDE",'error':0}, {'n':2,'value':params[2],'limits':[minpars[2],maxpars[2]],'limited':[limitedmin[2],limitedmax[2]],'fixed':fixed[2],'parname':"XSHIFT",'error':0}, {'n':3,'value':params[3],'limits':[minpars[3],maxpars[3]],'limited':[limitedmin[3],limitedmax[3]],'fixed':fixed[3],'parname':"YSHIFT",'error':0}, {'n':4,'value':params[4],'limits':[minpars[4],maxpars[4]],'limited':[limitedmin[4],limitedmax[4]],'fixed':fixed[4],'parname':"XWIDTH",'error':0}, {'n':5,'value':params[5],'limits':[minpars[5],maxpars[5]],'limited':[limitedmin[5],limitedmax[5]],'fixed':fixed[5],'parname':"YWIDTH",'error':0}, {'n':6,'value':params[6],'limits':[minpars[6],maxpars[6]],'limited':[limitedmin[6],limitedmax[6]],'fixed':fixed[6],'parname':"ROTATION",'error':0}, {'n':7,'value':params[7],'limits':[minpars[7],maxpars[7]],'limited':[limitedmin[7],limitedmax[7]],'fixed':fixed[7],'parname':"SPATIALFREQ",'error':0}, {'n':8,'value':params[8],'limits':[minpars[8],maxpars[8]],'limited':[limitedmin[8],limitedmax[8]],'fixed':fixed[8],'parname':"PHASE",'error':0} ] mp = mpfit(mpfitfun(data,err),parinfo=parinfo,quiet=quiet) if returnmp: returns = (mp) elif return_all == 0: returns = mp.params elif return_all == 1: returns = mp.params,mp.perror if returnfitimage: fitimage = twodgabor(mp.params)(*np.indices(data.shape)) returns = (returns,fitimage) return returns
def subreg(reference, images): bfixpix(reference,np.isnan(reference),n=8) kernel=reference[::-1,::-1] shifts=[] for im in images: bfixpix(im,np.isnan(im),n=8) cor = fftconvolve(im,kernel,mode='same') y,x=find_max_star(cor) g=gaussfit(cor[max(0, y-40):min(y+40, cor.shape[0]), max(0, x-40):min(x+40, cor.shape[1])]) shiftx=np.rint(cor.shape[1]/2.) - max(0,x-40)-g[2] shifty=np.rint(cor.shape[0]/2.) - max(0,y-40)-g[3] shifts.append((shifty,shiftx)) return shifts
def gaussBoxFitPoint(img, point, outLength): '''Given a point in an image and outLength to test, returns a 2d gaussian fit to the object around the point and its errors''' #print(point) bbout = getBrightBox(img, point, outLength) pixSet = bbout[0] # ~ sideLength = (outLength*2)+1 if checkOnePeak(pixSet) == True: # ~ xes = np.arange((outLength*2)+1) bits = gaussfit((pixSet), return_error='True', circle='True') # ~ drawGaussCircle(img, (bbout[2]+bits[0][2], bbout[1]+bits[0][3]), bits[0][4]) return ([bits[0], bits[1]]) else: return ([np.zeros(5), np.zeros(5)])
def fitgaussian(sta, f_size=10): max_i = np.unravel_index(np.argmax(np.abs(sta)), sta.shape) try: sta, max_i_cut = msc.cut_around_center(sta, max_i, f_size) except ValueError as e: if str(e).startswith('Frame is out'): raise ValueError('Fit failed.') fit_frame = sta[..., max_i_cut[-1]] # Parameters are in the format: # (height,amplitude,center_x,center_y,width_x,width_y,rota) pars = gfit.gaussfit(fit_frame) # f = gfit.twodgaussian(pars) pars_out = pars pars_out[2:4] = pars[2:4] - [f_size, f_size] + max_i[:2] return pars_out
def photon_finder_gaussians(image, centers): #commented for circle=1 param_names = [ 'angle', 'd_angle', 'offset', 'd_offset', 'amplitude', 'd_amplitude', 'xo', 'd_xo', 'yo', 'd_yo', 'sx', 'd_sx', 'sy', 'd_sy' ] res = {name: [] for name in param_names} for c in centers: xo, yo = tuple(map(int, c)) fit, cov_p, infodict, errmsg = gaussfit(image[xo - 4:xo + 4, yo - 4:yo + 4], circle=0, return_all=1) N = np.size(image[xo - 4:xo + 4, yo - 4:yo + 4]) n = len(fit) s_sq = (infodict['fvec']**2).sum() / ( N - n) # infodict already contains f(x)-y, which is needed cov = cov_p * s_sq stds = [np.sqrt(cov[i][i]) for i in range(len(fit))] #params = dict(zip(param_names, np.round(fit, 6))) params = dict(zip(param_names, np.round(fit, 7))) #const, amp, x, y, s, angle = fit const, amp, x, y, sx, sy, angle = fit x += xo y += yo res['offset'].append(const) res['amplitude'].append(amp) res['xo'].append(x) res['yo'].append(y) #res['s'].append(s) res['sy'].append(sy) res['sx'].append(sx) res['angle'].append(angle) res['d_offset'].append(stds[0]) res['d_amplitude'].append(stds[1]) res['d_xo'].append(stds[2]) res['d_yo'].append(stds[3]) res['d_sx'].append(stds[4]) res['d_sy'].append(stds[5]) res['d_angle'].append(stds[6]) fits = pd.DataFrame(res) #positions = pd.DataFrame(centers, columns=['xo', 'yo']) return fits
def compute_centroid(im,sigw=None,nb_iter=4): """ Computes centroid. #TODO: would be interesting to compare with Sam's moments based computation Calls: * gaussfitter.gaussfit """ if sigw is None: param=gaussfitter.gaussfit(im,returnfitimage=False) #print param sigw = (param[3]+param[4])/2 sigw = float(sigw) n1 = im.shape[0] n2 = im.shape[1] rx = array(range(0,n1)) ry = array(range(0,n2)) Wc = ones((n1,n2)) centroid = zeros((1,2)) # Four iteration loop to compute the centroid i=0 for i in range(0,nb_iter): xx = npma.outerproduct(rx-centroid[0,0],ones(n2)) yy = npma.outerproduct(ones(n1),ry-centroid[0,1]) W = npma.exp(-(xx**2+yy**2)/(2*sigw**2)) centroid = zeros((1,2)) # Estimate Centroid Wc = copy(W) if i == 0:Wc = ones((n1,n2)) totx=0.0 toty=0.0 cx=0 cy=0 for cx in range(0,n1): centroid[0,0] += (im[cx,:]*Wc[cx,:]).sum()*(cx) totx += (im[cx,:]*Wc[cx,:]).sum() for cy in range(0,n2): centroid[0,1] += (im[:,cy]*Wc[:,cy]).sum()*(cy) toty += (im[:,cy]*Wc[:,cy]).sum() centroid = centroid*array([1/totx,1/toty]) return (centroid,Wc)
def compute_centroid(im, sigw=None, nb_iter=4): """ Computes centroid. #TODO: would be interesting to compare with Sam's moments based computation Calls: * gaussfitter.gaussfit """ if sigw is None: param = gaussfitter.gaussfit(im, returnfitimage=False) #print param sigw = (param[3] + param[4]) / 2 sigw = float(sigw) n1 = im.shape[0] n2 = im.shape[1] rx = array(range(0, n1)) ry = array(range(0, n2)) Wc = ones((n1, n2)) centroid = zeros((1, 2)) # Four iteration loop to compute the centroid i = 0 for i in range(0, nb_iter): xx = npma.outerproduct(rx - centroid[0, 0], ones(n2)) yy = npma.outerproduct(ones(n1), ry - centroid[0, 1]) W = npma.exp(-(xx**2 + yy**2) / (2 * sigw**2)) centroid = zeros((1, 2)) # Estimate Centroid Wc = copy(W) if i == 0: Wc = ones((n1, n2)) totx = 0.0 toty = 0.0 cx = 0 cy = 0 for cx in range(0, n1): centroid[0, 0] += (im[cx, :] * Wc[cx, :]).sum() * (cx) totx += (im[cx, :] * Wc[cx, :]).sum() for cy in range(0, n2): centroid[0, 1] += (im[:, cy] * Wc[:, cy]).sum() * (cy) toty += (im[:, cy] * Wc[:, cy]).sum() centroid = centroid * array([1 / totx, 1 / toty]) return (centroid, Wc)
from astropy.io import fits import aplpy import pylab import pyregion import gaussfitter cube = SpectralCube.read(dpath('W51Ku_BD_h2co_v30to90_natural_contsub.image.fits')).with_spectral_unit(u.km/u.s, velocity_convention='radio') r = pyregion.open(rpath('W51_22_emission.reg')) scube = cube.subcube_from_ds9region(pyregion.ShapeList([x for x in r if 'text' in x.attr[1] and x.attr[1]['text']=='W51NorthCore'])) vr = [56,61] gaussfits = [gaussfitter.gaussfit( np.nan_to_num((scube[scube.closest_spectral_channel(v*u.km/u.s),:,:]/scube.max()).value), return_error=True ) for v in np.arange(vr[0],vr[1]+0.5,0.5)] centroids = np.array([gf[0][2:4] for gf in gaussfits]) ecentroids = np.array([gf[1][2:4] for gf in gaussfits]) fig = pl.figure(1) fig.clf() ax = fig.gca() sc = ax.scatter(centroids[:,0], centroids[:,1], marker='o', c=np.arange(vr[0],vr[1]+0.5,0.5), s=100) # sc doesn't have facecolors until it is drawn pl.draw() itr = zip(centroids[:,0], centroids[:,1], ecentroids[:,0], ecentroids[:,1], sc.get_facecolors()) print itr
def test_elliptical_fit(self): inpars = [0, 1, 64, 64, 4, 12, 30] in_data = gf.twodgaussian(inpars, shape=(128, 128)) fit = gf.gaussfit(in_data) for inval, outval in zip(inpars, fit): self.assertAlmostEqual(inval, outval)
except ValueError: continue fit_frame = sta[:, :, max_i[2]] if np.max(fit_frame) != np.max(np.abs(fit_frame)): onoroff = -1 else: onoroff = 1 Y, X = np.meshgrid(np.arange(fit_frame.shape[1]), np.arange(fit_frame.shape[0])) with warnings.catch_warnings(): warnings.filterwarnings('ignore', '.*divide by zero*.', RuntimeWarning) pars = gfit.gaussfit(fit_frame * onoroff) f = gfit.twodgaussian(pars) Z = f(X, Y) # Correcting for Mahalonobis dist. with warnings.catch_warnings(): warnings.filterwarnings('ignore', '.*divide by zero*.', RuntimeWarning) Zm = np.log((Z - pars[0]) / pars[1]) Zm[np.isinf(Zm)] = np.nan Zm = np.sqrt(Zm * -2) ax = plt.subplot(1, 2, 1) plf.subplottext('A', ax, x=0, y=1.3) vmax = np.abs(fit_frame).max() vmin = -vmax
#epoch1reproj = FITS_tools.hcongrid.hcongrid(epoch1[0].data, epoch1header, epoch3header) epoch1reproj, footprint = reproject.reproject(epoch1[0], epoch3header) scalefactor = (beam3.sr/beam1.sr).value xshift,yshift, ex, ey = image_registration.chi2_shift(epoch3[0].data, epoch1reproj*scalefactor, err=0.001) center = coordinates.SkyCoord(290.92443*u.deg, 14.515755*u.deg, frame='fk5') xx,yy = wcs1.wcs_world2pix([[center.fk4.ra.deg, center.fk4.dec.deg]], 0)[0] subim1 = epoch1[0].data[yy-10:yy+10, xx-10:xx+10] wcs1sub = wcs1[yy-10:yy+10, xx-10:xx+10] xx,yy = wcs3.wcs_world2pix([[center.fk5.ra.deg, center.fk5.dec.deg]], 0)[0] wcs3sub = wcs3[yy-10:yy+10, xx-10:xx+10] subim3 = epoch3[0].data[yy-10:yy+10, xx-10:xx+10] gf1 = gaussfitter.gaussfit(subim1) gf3 = gaussfitter.gaussfit(subim3) dx1,dy1 = gf1[2:4] dx3,dy3 = gf3[2:4] dx_gf, dy_gf = dx3-dx1, dy3-dy1 epoch1matched_fft = image_registration.fft_tools.shift2d(epoch1reproj*scalefactor, -xshift, -yshift) epoch1matched = image_registration.fft_tools.shift2d(epoch1reproj*scalefactor, dx_gf, dy_gf) diff = epoch3[0].data - epoch1matched diffhdu = fits.PrimaryHDU(data=diff, header=epoch3header) diffhdu.writeto(paths.dpath("Cband_Epoch3-Epoch1.fits"), clobber=True, output_verify='fix') smooth_beam = beam1.deconvolve(beam3) kernel = smooth_beam.major
def main(): file = open(outputFolder+'onOff.csv', "w") header = 'Unidad\t'+'OnOff\t'+'PeakFrame''\n' file.write(header) maxDataSTAValue = 0 minDataSTAValue = 0 for unitFile in sorted(os.listdir(sourceFolder)): unitName = unitFile.rsplit('_', 1)[0] if os.path.isdir(sourceFolder+unitFile): # The STA matrix is named as M8a_lineal/sta_array_M8a.mat staMatrixFile = scipy.io.loadmat(sourceFolder+unitFile+'/sta_array_'+unitName+'.mat') staMatrix = staMatrixFile['STA_array'] staMatrix = staMatrix[:,:,1:18] dataUnit, coordinates = rfe.loadSTACurve(sourceFolder,unitFile,unitName) print unitName print 'coordinates',coordinates media = numpy.mean(staMatrix) maximo = numpy.amax(staMatrix) minimo = numpy.amin(staMatrix) maximaDistancia = numpy.absolute(maximo-media) minimaDistancia = numpy.absolute(minimo-media) if maximaDistancia > minimaDistancia: frame = numpy.where(maximo==staMatrix)[2][0] linea = '"'+unitName+'"\t"On"\t"'+ str(frame + 1) + '\"\n' else: frame = numpy.where(minimo==staMatrix)[2][0] linea = '"'+unitName+'"\t"Off"\t"'+ str(frame + 1) + '\"\n' data = gf.moments(staMatrix[:,:,frame],circle=0,rotate=1,vheight=1) print 'frame',frame print 'height',data[0] print 'amplitude',data[1] print 'x',data[2] print 'y',data[3] print 'width_x',data[4] print 'width_y',data[5] print 'rotation',data[6] curva = staMatrix[data[3],data[2],:] from numpy import linspace,exp from numpy.random import randn import matplotlib.pyplot as plt from scipy.interpolate import UnivariateSpline x = linspace(1, len(curva), len(curva)) s = UnivariateSpline(x, curva, s=1) xs = linspace(1, len(curva), len(curva)*10) ys = s(xs) plt.plot(x, curva,'r') plt.plot(xs, ys,'b') plt.savefig(outputFolder+unitName+"_spline.png") plt.close() dataFit = gf.gaussfit(staMatrix[:,:,frame],autoderiv=1, \ return_all=1,circle=0,fixed=numpy.repeat(False,7), \ limitedmin=[False,False,False,False,True,True,True], \ limitedmax=[False,False,False,False,False,False,True], \ usemoment=[1,1,1,1],minpars=numpy.repeat(0,7),maxpars=[0,0,0,0,0,0,360], \ rotate=1,vheight=1,quiet=True,returnmp=False, \ returnfitimage=True) fig = plt.figure(1, figsize=(10,10)) ax = fig.add_subplot(111) plt.imshow(dataFit[1]) plt.savefig(outputFolder+unitName+".png") plt.close() file.write(linea) file.close return 0
from __future__ import division import pydc1394 as fw from time import sleep, time import numpy as np import pylab as pl import matplotlib.cm as cm import gaussfitter as gf if __name__ == "__main__": filename = 'img_343444' # filename = 'img' data = np.load('%s.npy' %filename) fit = gf.gaussfit(data) cmap = cm.gist_gray cmap = cm.jet fig = pl.figure(num=1, figsize=(11.69, 8.27)) pl.subplot(221) pl.imshow(data, cmap=cmap) pl.title('Image') pl.xlabel('x') pl.ylabel('y') pl.subplot(224) fdata = np.ravel((gf.twodgaussian(fit,0,1,1)\ (*np.indices(data.shape)))).reshape(np.shape(data)) pl.imshow(fdata) pl.xlabel('Fitted data')
def star_analysis(target_x, target_y): snippet_size = 50 # sub_image half_width full_image_data = pyfits.getdata(image_filepath) if (target_x < snippet_size) or (target_x > full_image_data.shape[1] - snippet_size) or (target_y < snippet_size) or (target_y > full_image_data.shape[0] - snippet_size): print "You must select a position at least", snippet_size, "pixels from the edge of the image. Aborting." return sub_image_data = full_image_data[target_y-snippet_size:target_y+snippet_size, target_x-snippet_size:target_x+snippet_size] # Run the 2D gaussian fit gauss_fit_results = gaussfit(sub_image_data) # gauss_fit_results has the format: # (height, amplitude, x, y, width_x, width_y, rotation angle), image gauss_fit_height = gauss_fit_results[0] gauss_fit_amplitude = gauss_fit_results[1] gauss_fit_x_center = gauss_fit_results[2] gauss_fit_y_center = gauss_fit_results[3] gauss_fit_x_width = gauss_fit_results[4] gauss_fit_y_width = gauss_fit_results[5] gauss_fit_x_fwhm = 2.35482*gauss_fit_x_width gauss_fit_y_fwhm = 2.35482*gauss_fit_y_width gauss_fit_fwhm = (gauss_fit_x_fwhm + gauss_fit_y_fwhm)/2. gauss_fit_ecc = (abs(1 - gauss_fit_x_fwhm/gauss_fit_y_fwhm)) sub_image_data = sub_image_data - gauss_fit_height z = [] x = [] y = [] for i in range(len(sub_image_data)): i_pixel = i + 0 for j in range(len(sub_image_data[i])): if sub_image_data[i][j] != 0: j_pixel = j + 0 x.append(j_pixel) y.append(i_pixel) z.append(sub_image_data[i][j]) r = ((x - gauss_fit_x_center)**2 + (y - gauss_fit_y_center)**2)**0.5 fit_curve_r = linspace(0, snippet_size, 400) gauss_fit_curve = gauss_fit_height + gauss_fit_amplitude * exp(-1* (fit_curve_r)**2 / (2 * ( (gauss_fit_x_width + gauss_fit_y_width)/2.)**2)) fit_params = fit_moffat(gauss_fit_x_center, gauss_fit_y_center, z, x, y) central_height, center_x, center_y, alpha, beta = fit_params fwhm_moffat = 2*alpha*sqrt(2**(1/beta) - 1) rad = sqrt( (x-center_x)**2 + (y-center_y)**2 ) h = where( rad < 3 * fwhm_moffat ) z_cropped = array(z)[h] x_cropped = array(x)[h] y_cropped = array(y)[h] r_cropped = array(r)[h] fit_params = fit_moffat(center_x, center_y, z_cropped, x_cropped, y_cropped) central_height, center_x, center_y, alpha, beta = fit_params fwhm_moffat = 2*alpha*sqrt(2**(1/beta) - 1) r2 = fit_curve_r**2 moffat_fit_curve = (central_height * (1 + (r2/(alpha**2)))**(-beta)) h_annulus = where((rad > 10 * fwhm_moffat) * (rad < 12 * fwhm_moffat)) z_annulus = array(z)[h_annulus] r_annulus = array(r)[h_annulus] clf() scatter(r_cropped, z_cropped, color="red", alpha=0.5) # scatter(r_annulus, z_annulus, color="orange", alpha=0.1) plot(fit_curve_r, gauss_fit_curve, color="blue", label="Gaussian Fit FWHM=" + str(round(gauss_fit_fwhm, 3))) plot(fit_curve_r, moffat_fit_curve, color="green", label="Moffat Fit FWHM=" + str(round(fwhm_moffat, 3))) # plot(fit_curve_r, median(z_annulus)*ones(fit_curve_r.size), color="green", label="Sky Background=" + str(round(median(z_annulus), 3))) xlim(0, fwhm_moffat*3.06) ylim(max(gauss_fit_height+gauss_fit_amplitude, central_height)*-0.1, max(gauss_fit_height+gauss_fit_amplitude, central_height)*1.05) xlabel("Radius [px]") ylabel("Flux Counts [ADU]") legend(loc=1) show() return
# rr = radius grid rr = ((xx-rp*3)**2+(yy-rp*3)**2)**0.5 # mask = pixels within 1 beam radius mask = rr<rp if mask.sum() and np.isfinite(co[mask]).sum() > 12: peaks[freq][name] = co[mask].max() valleys[freq][name] = co.min() params = [co.min(), co[mask].max(), 3*rp, 3*rp, 2.0, 2.0, 45.0] # fit NaN-containing images co[~np.isfinite(co)] = 0.0 try: mp, fitimg = gaussfitter.gaussfit(co, params=params, err=error[freq], returnmp=True, rotate=True, vheight=True, circle=False, returnfitimage=True) except: mpfits[freq][name] = () gpars[freq][name] = np.array([np.nan]*7) gparerrs[freq][name] = np.array([np.nan]*7) continue mpfits[freq][name] = mp gpars[freq][name] = mp.params gparerrs[freq][name] = mp.perror gfits[freq][name] = fitimg wcsX,wcsY = wcs.wcs_pix2world(mp.params[2]+int(xc-3*rp), mp.params[3]+int(yc-3*rp), 0) center_coord = coordinates.SkyCoord(wcsX*u.deg, wcsY*u.deg,
for i in range(ring_sizes2[0], ring_sizes2[1]): plt.subplot(4, 2, 3) masked = mf.ringmask(sta, max_i, i) if not masked[1]: plt.plot(np.mean(masked[0], axis=(0, 1)), label=str(i)) plt.legend() # %% Fit 2D Gaussian # fit_frame = sta[:, :, max_i[2]] # f_size = 20 # # if f_size is not 0: # fit_frame = fit_frame[max_i[0]-f_size:max_i[0]+f_size+1, # max_i[1]-f_size:max_i[1]+f_size+1] pars = gfit.gaussfit(fit_frame) f = gfit.twodgaussian(pars) Y, X = np.meshgrid(np.arange(fit_frame.shape[1]), np.arange(fit_frame.shape[0])) Z = f(X, Y) # Correcting for Mahalonobis dist. # Using a second variable Zm2 to not break how it currently works and # easily revert Zm2 = np.log((Z - pars[0]) / pars[1]) Zm2[np.isinf(Zm2)] = np.nan Zm = np.sqrt(Zm2 * -2) # To workaround negative values from before, remove minus from Zm comparisons to fix this # Zm = -Zm # Zmr = np.ceil(Zm)
def plotcheckersurround(exp_name, stim_nr, filename=None, spikecutoff=1000, ratingcutoff=4, staqualcutoff=0, inner_b=2, outer_b=4): """ Divides into center and surround by fitting 2D Gaussian, and plot temporal components. spikecutoff: Minimum number of spikes to include. ratingcutoff: Minimum spike sorting rating to include. staqualcutoff: Minimum STA quality (as measured by z-score) to include. inner_b: Defined limit between receptive field center and surround in units of sigma. outer_b: Defined limit of the end of receptive field surround. """ exp_dir = iof.exp_dir_fixer(exp_name) stim_nr = str(stim_nr) if filename: filename = str(filename) if not filename: savefolder = 'surroundplots' label = '' else: label = filename.strip('.npz') savefolder = 'surroundplots_' + label _, metadata = asc.read_spikesheet(exp_name) px_size = metadata['pixel_size(um)'] data = iof.load(exp_name, stim_nr, fname=filename) clusters = data['clusters'] stas = data['stas'] stx_h = data['stx_h'] exp_name = data['exp_name'] stimname = data['stimname'] max_inds = data['max_inds'] frame_duration = data['frame_duration'] filter_length = data['filter_length'] quals = data['quals'][-1, :] spikenrs = data['spikenrs'] c1 = np.where(spikenrs > spikecutoff)[0] c2 = np.where(clusters[:, 2] <= ratingcutoff)[0] c3 = np.where(quals > staqualcutoff)[0] choose = [i for i in range(clusters.shape[0]) if ((i in c1) and (i in c2) and (i in c3))] clusters = clusters[choose] stas = list(np.array(stas)[choose]) max_inds = list(np.array(max_inds)[choose]) clusterids = plf.clusters_to_ids(clusters) t = np.arange(filter_length)*frame_duration*1000 # Determine frame size so that the total frame covers # an area large enough i.e. 2*700um f_size = int(700/(stx_h*px_size)) del data for i in range(clusters.shape[0]): sta_original = stas[i] max_i_original = max_inds[i] try: sta, max_i = mf.cut_around_center(sta_original, max_i_original, f_size) except ValueError: continue fit_frame = sta[:, :, max_i[2]] if np.max(fit_frame) != np.max(np.abs(fit_frame)): onoroff = -1 else: onoroff = 1 Y, X = np.meshgrid(np.arange(fit_frame.shape[1]), np.arange(fit_frame.shape[0])) with warnings.catch_warnings(): warnings.filterwarnings('ignore', '.*divide by zero*.', RuntimeWarning) pars = gfit.gaussfit(fit_frame*onoroff) f = gfit.twodgaussian(pars) Z = f(X, Y) # Correcting for Mahalonobis dist. with warnings.catch_warnings(): warnings.filterwarnings('ignore', '.*divide by zero*.', RuntimeWarning) Zm = np.log((Z-pars[0])/pars[1]) Zm[np.isinf(Zm)] = np.nan Zm = np.sqrt(Zm*-2) ax = plt.subplot(1, 2, 1) plf.stashow(fit_frame, ax) ax.set_aspect('equal') with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=UserWarning) warnings.filterwarnings('ignore', '.*invalid value encountered*.') ax.contour(Y, X, Zm, [inner_b, outer_b], cmap=plf.RFcolormap(('C0', 'C1'))) barsize = 100/(stx_h*px_size) scalebar = AnchoredSizeBar(ax.transData, barsize, '100 µm', 'lower left', pad=1, color='k', frameon=False, size_vertical=.2) ax.add_artist(scalebar) with warnings.catch_warnings(): warnings.filterwarnings('ignore', '.*invalid value encountered in*.', RuntimeWarning) center_mask = np.logical_not(Zm < inner_b) center_mask_3d = np.broadcast_arrays(sta, center_mask[..., None])[1] surround_mask = np.logical_not(np.logical_and(Zm > inner_b, Zm < outer_b)) surround_mask_3d = np.broadcast_arrays(sta, surround_mask[..., None])[1] sta_center = np.ma.array(sta, mask=center_mask_3d) sta_surround = np.ma.array(sta, mask=surround_mask_3d) sta_center_temporal = np.mean(sta_center, axis=(0, 1)) sta_surround_temporal = np.mean(sta_surround, axis=(0, 1)) ax1 = plt.subplot(1, 2, 2) l1 = ax1.plot(t, sta_center_temporal, label='Center\n(<{}σ)'.format(inner_b), color='C0') sct_max = np.max(np.abs(sta_center_temporal)) ax1.set_ylim(-sct_max, sct_max) ax2 = ax1.twinx() l2 = ax2.plot(t, sta_surround_temporal, label='Surround\n({}σ<x<{}σ)'.format(inner_b, outer_b), color='C1') sst_max = np.max(np.abs(sta_surround_temporal)) ax2.set_ylim(-sst_max, sst_max) plf.spineless(ax1) plf.spineless(ax2) ax1.tick_params('y', colors='C0') ax2.tick_params('y', colors='C1') plt.xlabel('Time[ms]') plt.axhline(0, linestyle='dashed', linewidth=1) lines = l1+l2 labels = [line.get_label() for line in lines] plt.legend(lines, labels, fontsize=7) plt.title('Temporal components') plt.suptitle(f'{exp_name}\n{stimname}\n{clusterids[i]}') plt.subplots_adjust(wspace=.5, top=.85) plotpath = os.path.join(exp_dir, 'data_analysis', stimname, savefolder) if not os.path.isdir(plotpath): os.makedirs(plotpath, exist_ok=True) plt.savefig(os.path.join(plotpath, clusterids[i])+'.svg', format='svg', dpi=300) plt.close() print(f'Plotted checkerflicker surround for {stimname}')
import gaussfitter input_parameters = [0, 1, 25, 25, 3, 6, 30] print("Input parameters are: {0}".format(input_parameters)) example_gaussian = gaussfitter.twodgaussian(input_parameters, shape=[50,50],) moments = gaussfitter.moments(example_gaussian, circle=False, rotate=True, vheight=True) print("These are the input guesses computed using 'moments':") print(moments) print("This is from the gaussian fit; it works well:") print(gaussfitter.gaussfit(example_gaussian))
def compact_fit(): params,gaussdata=g.gaussfit(img,returnfitimage=True) #gives height, amp, center_x, center_y, widthx, widthy, rotation height,amp,cx,cy,widthx,widthy,rot=params return height,amp,cx,cy,widthx,widthy,rot,gaussdata
def peak_attribs_image(image, peak_width=None, target_locations=None, medfilt_radius=None, xc_filter=True, progress_object=PyFaceProgress(), kill_edges=True, kill_duplicates=True): """ Characterizes the peaks in an image. Parameters: ---------- peak_width : int (optional) expected peak width. Affects characteristic fitting window. Too big, and you'll include other peaks in the measurement. Too small, and you'll get spurious peaks around your peaks. Default is None (attempts to auto-detect) target_locations : numpy array (n x 2) array of n target locations. If left as None, will create target locations by locating peaks on the average image of the stack. default is None (peaks detected from average image) medfilt_radius : int (optional) median filter window to apply to smooth the data (see scipy.signal.medfilt) if 0, no filter will be applied. default is set to 5 Returns: ------- 2D numpy array: - One row per peak - 7 columns: 0,1 - location 2 - height 3,4 - long and short axis length 5 - orientation 6 - eccentricity 7,8 - skew """ try: import cv except: try: import cv2.cv as cv except: print 'Module %s:' % sys.modules[__name__] print 'OpenCV is not available, the peak characterization functions will not work.' return None if target_locations is None: # target locations should be a list of arrays. Each element in the # list corresponds to a recursion level in peak finding. The peak # width can change with each recursion. target_locations = two_dim_findpeaks(image, peak_width=peak_width, medfilt_radius=medfilt_radius, xc_filter=xc_filter, kill_edges=kill_edges, kill_duplicates=kill_duplicates) imsize = image.shape[0] total_peaks = target_locations.shape[0] rlt = np.zeros((total_peaks, 9)) if progress_object is not None: progress_object.initialize("Characterizing peaks", total_peaks) rlt_offset = 0 if peak_width is None: peak_width = estimate_peak_width(image) r = int(np.ceil(peak_width / 2)) roi = np.zeros((r * 2, r * 2)) mask = draw_mask((r * 2, r * 2), r, [(r, r)]) for c in target_locations: peak_left = int(c[0] - r) peak_top = int(c[1] - r) peak_right = int(c[0] + r) peak_bottom = int(c[1] + r) #if bxmin<0: bxmin=0; bxmax=peak_width #if bymin<0: bymin=0; bymax=peak_width #if bxmax>imsize: bxmax=imsize; bxmin=imsize-peak_width #if bymax>imsize: bymax=imsize; bymin=imsize-peak_width # skip peaks that are too close to edges. if (peak_right) > image.shape[1] + r / 4 or ( peak_bottom) > image.shape[0] + r / 4: if progress_object is not None: progress_object.increment() continue # set the neighborhood of the peak to zero so we go look elsewhere # for other peaks x = np.array(np.arange(peak_left, peak_right), dtype=np.integer) y = np.array(np.arange(peak_top, peak_bottom), dtype=np.integer) xv, yv = np.meshgrid(x, y) roi[:, :] = image[xv.clip(0, image.shape[0] - 1), yv.clip(0, image.shape[1] - 1)] * mask #roi[0:,:]=image[bymin:bymax,bxmin:bxmax] # skip frames with significant dead pixels (corners of # rotated images, perhaps #if np.average(roi)< 0.5*np.average(image): #rlt[loc,:2] = (c[1], c[0]) #continue ms = cv.Moments(cv.fromarray(roi)) # output from get_characteristics is: # x, y, height, long_axis, short_axis, orientation, eccentricity, skew_x, skew_y rlt[rlt_offset] = get_characteristics(ms) # order for these is: # amp, xShift, yShift, xWidth, height, yWidth, Rotation # WTF??? Why is this different from return order!? # I'm a control freak... limit_min = [True, True, True, True, True, True, True] limit_max = [True, True, True, True, True, True, True] # 30 pixels seems like a hell of a lot for a peak... max_width = 30 max_height = 1.2 * np.max(roi) ctr = np.array(roi.shape) / 2 min_height = np.mean(image) / 1.5 x = rlt[rlt_offset][0] y = rlt[rlt_offset][1] amp = image[int(peak_left + x), int(peak_top + y)] long_axis = rlt[rlt_offset][3] short_axis = rlt[rlt_offset][4] orientation = rlt[rlt_offset][5] height = 0 params = [amp, x, y, long_axis, height, short_axis, orientation] minpars = [min_height, x - 2, y - 2, 0, 0, 0, 0] maxpars = [max_height, x + 2, y + 2, max_width, 0, max_width, 360] # TODO: could use existing moments or parameters to speed up... amp, fit_x, fit_y, width_x, height, width_y, rot = gaussfit( roi, limitedmin=limit_min, limitedmax=limit_max, maxpars=maxpars, minpars=minpars, params=params) # x and y are the locations within the ROI. Add the coordinates of # the top-left corner of our ROI on the global image. rlt[rlt_offset, :2] = (np.array([peak_left, peak_top]) + np.array([fit_x, fit_y])) #rlt[loc,:2] = np.array([y,x]) # insert the height rlt[rlt_offset, 2] = amp + height # TODO: compare this with OpenCV moment calculation above: # (this is using the gaussfitter value) rlt[rlt_offset, 5] = rot rlt_offset += 1 if progress_object is not None: progress_object.increment() # chuck outliers based on median of height d = np.abs(rlt[:, 2] - np.median(rlt[:, 2])) mdev = np.median(d) s = d / mdev if mdev else 0 # kill outliers based on height rlt = rlt[np.logical_and(s < 10, rlt[:, 2] < image.max() * 1.3)] # kill peaks that are too close to other peaks # the minimum width is 1.5 times the smallest peak width. #min_width = 1.5*target_locations[-1][0][3] #rlt = kill_duplicates(rlt,min_width) return rlt
def peak_attribs_image(image, peak_width=None, target_locations=None, medfilt_radius=None, xc_filter=True, progress_object=PyFaceProgress(), kill_edges=True, kill_duplicates=True): """ Characterizes the peaks in an image. Parameters: ---------- peak_width : int (optional) expected peak width. Affects characteristic fitting window. Too big, and you'll include other peaks in the measurement. Too small, and you'll get spurious peaks around your peaks. Default is None (attempts to auto-detect) target_locations : numpy array (n x 2) array of n target locations. If left as None, will create target locations by locating peaks on the average image of the stack. default is None (peaks detected from average image) medfilt_radius : int (optional) median filter window to apply to smooth the data (see scipy.signal.medfilt) if 0, no filter will be applied. default is set to 5 Returns: ------- 2D numpy array: - One row per peak - 7 columns: 0,1 - location 2 - height 3,4 - long and short axis length 5 - orientation 6 - eccentricity 7,8 - skew """ try: import cv except: try: import cv2.cv as cv except: print 'Module %s:' % sys.modules[__name__] print 'OpenCV is not available, the peak characterization functions will not work.' return None if target_locations is None: # target locations should be a list of arrays. Each element in the # list corresponds to a recursion level in peak finding. The peak # width can change with each recursion. target_locations=two_dim_findpeaks(image, peak_width=peak_width, medfilt_radius=medfilt_radius, xc_filter=xc_filter, kill_edges=kill_edges, kill_duplicates=kill_duplicates) imsize=image.shape[0] total_peaks = target_locations.shape[0] rlt=np.zeros((total_peaks,9)) if progress_object is not None: progress_object.initialize("Characterizing peaks", total_peaks) rlt_offset=0 if peak_width is None: peak_width=estimate_peak_width(image) r=int(np.ceil(peak_width/2)) roi=np.zeros((r*2,r*2)) mask = draw_mask((r*2,r*2), r, [(r,r)]) for c in target_locations: peak_left=int(c[0]-r) peak_top=int(c[1]-r) peak_right=int(c[0]+r) peak_bottom=int(c[1]+r) #if bxmin<0: bxmin=0; bxmax=peak_width #if bymin<0: bymin=0; bymax=peak_width #if bxmax>imsize: bxmax=imsize; bxmin=imsize-peak_width #if bymax>imsize: bymax=imsize; bymin=imsize-peak_width # skip peaks that are too close to edges. if (peak_right)>image.shape[1]+r/4 or (peak_bottom)>image.shape[0]+r/4: if progress_object is not None: progress_object.increment() continue # set the neighborhood of the peak to zero so we go look elsewhere # for other peaks x = np.array(np.arange(peak_left, peak_right),dtype=np.integer) y = np.array(np.arange(peak_top, peak_bottom),dtype=np.integer) xv,yv = np.meshgrid(x,y) roi[:,:] = image[xv.clip(0,image.shape[0]-1), yv.clip(0,image.shape[1]-1)] * mask #roi[0:,:]=image[bymin:bymax,bxmin:bxmax] # skip frames with significant dead pixels (corners of # rotated images, perhaps #if np.average(roi)< 0.5*np.average(image): #rlt[loc,:2] = (c[1], c[0]) #continue ms=cv.Moments(cv.fromarray(roi)) # output from get_characteristics is: # x, y, height, long_axis, short_axis, orientation, eccentricity, skew_x, skew_y rlt[rlt_offset] = get_characteristics(ms) # order for these is: # amp, xShift, yShift, xWidth, height, yWidth, Rotation # WTF??? Why is this different from return order!? # I'm a control freak... limit_min = [True, True, True, True, True, True, True] limit_max = [True, True, True, True, True, True, True] # 30 pixels seems like a hell of a lot for a peak... max_width=30 max_height = 1.2*np.max(roi) ctr = np.array(roi.shape)/2 min_height = np.mean(image)/1.5 x = rlt[rlt_offset][0] y = rlt[rlt_offset][1] amp = image[int(peak_left+x),int(peak_top+y)] long_axis = rlt[rlt_offset][3] short_axis = rlt[rlt_offset][4] orientation = rlt[rlt_offset][5] height = 0 params = [amp, x, y, long_axis, height, short_axis, orientation] minpars = [min_height, x-2, y-2, 0, 0, 0, 0] maxpars = [max_height, x+2, y+2, max_width, 0, max_width, 360] # TODO: could use existing moments or parameters to speed up... amp, fit_x, fit_y, width_x, height, width_y, rot = gaussfit(roi, limitedmin=limit_min, limitedmax=limit_max, maxpars=maxpars, minpars=minpars, params=params ) # x and y are the locations within the ROI. Add the coordinates of # the top-left corner of our ROI on the global image. rlt[rlt_offset,:2] = (np.array([peak_left,peak_top]) + np.array([fit_x,fit_y])) #rlt[loc,:2] = np.array([y,x]) # insert the height rlt[rlt_offset,2]=amp+height # TODO: compare this with OpenCV moment calculation above: # (this is using the gaussfitter value) rlt[rlt_offset,5]=rot rlt_offset+=1 if progress_object is not None: progress_object.increment() # chuck outliers based on median of height d = np.abs(rlt[:,2] - np.median(rlt[:,2])) mdev = np.median(d) s = d/mdev if mdev else 0 # kill outliers based on height rlt=rlt[np.logical_and(s<10, rlt[:,2]<image.max()*1.3)] # kill peaks that are too close to other peaks # the minimum width is 1.5 times the smallest peak width. #min_width = 1.5*target_locations[-1][0][3] #rlt = kill_duplicates(rlt,min_width) return rlt
r = pyregion.open(rpath('W51_22_emission.reg')) r_subset = pyregion.ShapeList([x for x in r if 'text' in x.attr[1] and x.attr[1]['text']=='e8mol_ext']) scube = cube.subcube_from_ds9region(r_subset) pixscale = scube.wcs.pixel_scale_matrix[1,1]*u.deg pixscale_as = pixscale.to(u.arcsec) cubemax = scube.max() # normalize everything noise = scube.spectral_slab(30*u.km/u.s, 50*u.km/u.s).std(axis=0) noise[np.isnan(noise.value)] = 1e10*noise.unit noise_norm = (noise / cubemax).value dv = cube.spectral_axis.diff().mean() vr = [57,64] gaussfits = [gaussfitter.gaussfit( np.nan_to_num((scube[scube.closest_spectral_channel(v*u.km/u.s),:,:]/cubemax).value), err=noise_norm, return_error=True) for v in ProgressBar(np.arange(vr[0],vr[1]+dv.value,dv.value))] integrated_image = (scube.spectral_slab(vr[0]*u.km/u.s, vr[1]*u.km/u.s).moment0(axis=0)) gaussfit_total,fitimage = gaussfitter.gaussfit(np.nan_to_num(integrated_image.value), err=noise.value, returnfitimage=True ) # sanity check: make sure the fit is OK (it is) pl.figure(2).clf() pl.imshow(integrated_image.value, cmap=pl.cm.bone_r) cb = pl.colorbar() pl.contour(fitimage, cmap=pl.cm.spectral) pl.savefig(fpath('sanitycheck_w51e8_core_gaussfits_{0}.png'.format(name)))
x,y = cube.wcs.sub([wcs.WCSSUB_CELESTIAL]).wcs_world2pix([region.coord_list], 0)[0] # not sure why, but it looks like all the images are offset by 1 pix x = x+1 y = y+1 cutout = cube[channel, y-dy:y+dy, x-dx:x+dx].value rms = cube[channel, :20, :20].std() #params: (height, amplitude, x, y, width_x, width_y, rota) (pars, errors), fitimage = gaussfit(cutout, err=rms, params=(0, cutout[dy,dx], dx, dy, 1, 1, 0), limitedmin=[False,False,True,True,True,True,True], limitedmax=[False,False,True,True,False,False,True], minpars=[0,0,dx-1,dy-1,0,0,0], maxpars=[0,0,dx+1,dy+1,2.5,2.5,180], returnfitimage=True, return_error=True) #print(dict(zip(parnames, zip(pars, errors)))) row = dict(zip(parnames, pars)) row.update(dict(zip(['e'+p for p in parnames], errors))) row.update({'velocity': vcube.spectral_axis[channel]}) tbl.add_row(row) tbl.pprint() pl.figure(ii / 16) ax = pl.subplot(4, 4, ii % 16 + 1) ax.imshow(cutout, cmap=pl.cm.gray_r) ax.contour(fitimage)
import numpy as np import gaussfitter from astropy.io import fits from astropy import units as u from astropy import wcs cutout_size = 5 im = fits.getdata('gc450.fits.gz')[462 - cutout_size:462 + cutout_size, 1392 - cutout_size:1392 + cutout_size] pars = gaussfitter.gaussfit(im, params=[1, 20, cutout_size, cutout_size, 2, 2, 0]) w = wcs.WCS(fits.getheader('gc450.fits.gz')) fwhm = (wcs.utils.proj_plane_pixel_scales(w) * u.deg).to( u.arcsec) * pars[4:6] * np.sqrt(8 * np.log(2)) print("FWHM of Sgr B2 N = {0}".format(fwhm)) im = fits.getdata('gc450.fits.gz')[454 - cutout_size:454 + cutout_size, 1405 - cutout_size:1405 + cutout_size] pars = gaussfitter.gaussfit(im, params=[1, 20, cutout_size, cutout_size, 2, 2, 0]) w = wcs.WCS(fits.getheader('gc450.fits.gz')) fwhm = (wcs.utils.proj_plane_pixel_scales(w) * u.deg).to( u.arcsec) * pars[4:6] * np.sqrt(8 * np.log(2)) print("FWHM of Sgr B2 M = {0}".format(fwhm)) im = fits.getdata('gc450.fits.gz')[456 - cutout_size:456 + cutout_size,
if (ima[0].header['filter'] == obs_par['FILTER']): print "filename", files[i[0]] ima[1].data = ima[1].data * ima[0].header[ 'exptime'] #multiply by exptime to convert data to counts LTV1 = ima[1].header['LTV1'] #X offset to get into physical pixels LTV2 = ima[1].header['LTV2'] #Y offset to get to physical pixels nrow = len(ima[1].data[:, 0]) ncol = len(ima[1].data[0, :]) t = ima[0].header['expstart'] dat = ima[1].data[rmin:rmax, cmin:cmax] #cuts out stamp around the target star err = ima[2].data[rmin:rmax, cmin:cmax] results = gaussfitter.gaussfit(dat, err) if diagnostics == True: plt.title("Direct image") plt.imshow(dat * ima[0].header['exptime'], origin='lower', vmin=0, vmax=1000) plt.plot(results[2], results[3], marker='x', color='orange', markeredgewidth=3., ms=10, label='centroid', linestyle="none")
def align_stars(indir, outdir=None, ncpu=1, keepfrac=0.7): if outdir == None: outdir = indir pxhalf = 100 #px right and left of image. final size 2*pxhalf+1 filetable = ascii.read(indir + 'filetable_bkgrnd.csv', delimiter=',') nimages = len(filetable) #read in the images PAs = [] images = [] for ii, fn in enumerate(filetable['fninterm']): data, head = fits.getdata(fn, header=True) if not len(data.shape) == 2: raise ValueError('Unknown data fromat at file %s' % fn) starx = int(filetable[ii]['roughx']) stary = int(filetable[ii]['roughy']) # nims = data.shape[0] datacut = np.full([2 * pxhalf + 1, 2 * pxhalf + 1], np.nan) data = data[max(0, stary - pxhalf):min(stary + pxhalf + 1, data.shape[1]), max(0, starx - pxhalf):min(starx + pxhalf + 1, data.shape[0]), ] datacut[0:data.shape[0], 0:data.shape[1]] = data PAs.append(head[hpa]) images.append(datacut) # for hh in range(nims): # images.append( data[hh,:,:]) #///////////////////////////////////////////////////////// #median combine and first xreg #///////////////////////////////////////////////////////// print('register number getting medianed: ', len(images)) print(images[0].size) print(images[0].shape) print(images[0].dtype) first_median = np.median(images, axis=0) pool = Pool(ncpu) get_shifts = subreg(first_median) shifts = pool.map(get_shifts, images) first_shifts = shifts pool.close() for hh in range(len(images)): images[hh] = shift(images[hh], shifts[hh]) #///////////////////////////////////////////////////////// #keep only the best of images #///////////////////////////////////////////////////////// cross_reg = [] for im in images: cross_reg.append(np.sum((im - first_median)**2.)) sorted_cross_reg = np.argsort(cross_reg) selected_cross_reg = sorted_cross_reg[0:int(keepfrac * len(images))] n_selected = len(selected_cross_reg) #///////////////////////////////////////////////////////// #median combine and second xreg #///////////////////////////////////////////////////////// images = np.array(images)[selected_cross_reg, :, :] second_median = np.median(images, axis=0) print 'second subreg' pool = Pool(ncpu) get_shifts = subreg(second_median) shifts = pool.map(get_shifts, images) second_shifts = shifts pool.close() #get center for images. Move to pxhalf xycen = [] for h in range(n_selected): # xycen.append( get_center(images[h,:,:]) ) xycen.append( gaussfit(images[h,pxhalf-5:pxhalf+5, pxhalf-5:pxhalf+5],\ params=(0.,-200.,6.,6.,3.,3.,0.))[2:4] - [5.,5.]) yxcenshift = np.median(xycen, axis=0)[::-1] #- [pxhalf,pxhalf] print('General offset of images: %s' % yxcenshift) for h in range(n_selected): shifts[h] += yxcenshift images[h, :, :] = shift(images[h, :, :], shifts[h]) #///////////////////////////////////////////////////////// #save #///////////////////////////////////////////////////////// images = np.stack(images, axis=0) PAs = np.array(PAs) PAs_sel = PAs[selected_cross_reg] filet_sel = filetable[selected_cross_reg] filet_sel['orig_nr'] = selected_cross_reg fits.writeto(outdir + 'center_im_sat.fits', images, clobber=True) fits.writeto(outdir + 'rotnth.fits', PAs, clobber=True) print( 'DONE WITH ALL. SAVED DEROTATED IMAGES AND ANGLES IN %s. Their shape is %s' % (outdir, images.shape))
def gaborfit( data, err=None, params=(), fixed=np.repeat(False, 9), limitedmin=[False, False, False, False, True, True, True, True, True], limitedmax=[ False, False, False, False, False, False, True, False, True ], minpars=[0.0, 0.0, 0.0, 0.0, 0.01, 0.01, 0.0, 0.01, 0.0], maxpars=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 360.0, 0.0, 360.0], quiet=True, returnmp=False, return_all=False, returnfitimage=False, **kwargs): """ gabor params = (height,amplitude,center_x,center_y,width_x,width_y,theta,lambda,phi) """ """ gaussian params=(height, amplitude, center_x, center_y, width_x, width_y, theta) """ if len(params) == 0: params,_errors = gaussfit(data,limitedmin=limitedmin[:7],limitedmax=limitedmax[:7],\ minpars=minpars[:7],maxpars=maxpars[:7],return_all=True) spatial_freq = math.sqrt(params[2]**2 + params[3]**2) phase = 0.0 params = np.append(params, np.array([spatial_freq, phase], dtype='float')) def mpfitfun(data, err): if err is None: def f(p, fjac=None): return [0,np.ravel(data-twodgabor(p)\ (*np.indices(data.shape)))] else: def f(p, fjac=None): return [0,np.ravel((data-twodgabor(p)\ (*np.indices(data.shape)))/err)] return f parinfo = [{ 'n': 0, 'value': params[0], 'limits': [minpars[0], maxpars[0]], 'limited': [limitedmin[0], limitedmax[0]], 'fixed': fixed[0], 'parname': "HEIGHT", 'error': 0 }, { 'n': 1, 'value': params[1], 'limits': [minpars[1], maxpars[1]], 'limited': [limitedmin[1], limitedmax[1]], 'fixed': fixed[1], 'parname': "AMPLITUDE", 'error': 0 }, { 'n': 2, 'value': params[2], 'limits': [minpars[2], maxpars[2]], 'limited': [limitedmin[2], limitedmax[2]], 'fixed': fixed[2], 'parname': "XSHIFT", 'error': 0 }, { 'n': 3, 'value': params[3], 'limits': [minpars[3], maxpars[3]], 'limited': [limitedmin[3], limitedmax[3]], 'fixed': fixed[3], 'parname': "YSHIFT", 'error': 0 }, { 'n': 4, 'value': params[4], 'limits': [minpars[4], maxpars[4]], 'limited': [limitedmin[4], limitedmax[4]], 'fixed': fixed[4], 'parname': "XWIDTH", 'error': 0 }, { 'n': 5, 'value': params[5], 'limits': [minpars[5], maxpars[5]], 'limited': [limitedmin[5], limitedmax[5]], 'fixed': fixed[5], 'parname': "YWIDTH", 'error': 0 }, { 'n': 6, 'value': params[6], 'limits': [minpars[6], maxpars[6]], 'limited': [limitedmin[6], limitedmax[6]], 'fixed': fixed[6], 'parname': "ROTATION", 'error': 0 }, { 'n': 7, 'value': params[7], 'limits': [minpars[7], maxpars[7]], 'limited': [limitedmin[7], limitedmax[7]], 'fixed': fixed[7], 'parname': "SPATIALFREQ", 'error': 0 }, { 'n': 8, 'value': params[8], 'limits': [minpars[8], maxpars[8]], 'limited': [limitedmin[8], limitedmax[8]], 'fixed': fixed[8], 'parname': "PHASE", 'error': 0 }] mp = mpfit(mpfitfun(data, err), parinfo=parinfo, quiet=quiet) if returnmp: returns = (mp) elif return_all == 0: returns = mp.params elif return_all == 1: returns = mp.params, mp.perror if returnfitimage: fitimage = twodgabor(mp.params)(*np.indices(data.shape)) returns = (returns, fitimage) return returns
nearDeadCutoff=500#100/15 cps for 4000-6000 angstroms err[frame<nearDeadCutoff] = np.inf entireMask = (err==np.inf) maFrame = np.ma.masked_array(frame,entireMask) guessAmp = 2000. guessHeight = 2000. guessWidth=3. guessParams = [guessHeight,guessAmp,guessX,guessY,guessWidth] limitedmin = 5*[True] limitedmax = 5*[True] minpars = [0,0,0,0,.1] maxpars = [5000,10000,43,45,10] usemoments=[True,True,True,True,True] out = gaussfit(data=maFrame,err=err,params=guessParams,returnfitimage=True,quiet=True,limitedmin=limitedmin,limitedmax=limitedmax,minpars=minpars,maxpars=maxpars,circle=1,usemoments=usemoments,returnmp=True) mp = out[0] outparams = mp.params paramErrors = mp.perror chisq = mp.fnorm dof = mp.dof reducedChisq = chisq/dof print reducedChisq fitimg = out[1] chisqList.append([chisq,dof]) paramsList.append(outparams) errorsList.append(paramErrors) print outparams,paramErrors
]) scube = cube.subcube_from_ds9region(r_subset) pixscale = scube.wcs.pixel_scale_matrix[1, 1] * u.deg pixscale_as = pixscale.to(u.arcsec) cubemax = scube.max() # normalize everything noise = scube.spectral_slab(30 * u.km / u.s, 50 * u.km / u.s).std(axis=0) noise[np.isnan(noise)] = 1e10 * noise.unit noise_norm = (noise / cubemax).value dv = cube.spectral_axis.diff().mean() vr = [56, 63.5] gaussfits = [ gaussfitter.gaussfit(np.nan_to_num( (scube[scube.closest_spectral_channel(v * u.km / u.s), :, :] / cubemax).value), err=noise_norm, return_error=True) for v in ProgressBar(np.arange(vr[0], vr[1] + dv.value, dv.value)) ] integrated_image = (scube.spectral_slab(vr[0] * u.km / u.s, vr[1] * u.km / u.s).moment0(axis=0)) gaussfit_total, fitimage = gaussfitter.gaussfit(np.nan_to_num( integrated_image.value), err=noise.value, returnfitimage=True) # sanity check: make sure the fit is OK (it is) pl.figure(2).clf() pl.imshow(integrated_image.value, cmap=pl.cm.bone_r) cb = pl.colorbar()
peak = [csize-scsize+peak_[0], csize-scsize+peak_[1]] limitedmin=[F,T,T,T,T,T,T] limitedmax=[F,F,T,T,T,T,T] minpars=[0, 0, peak[1]-2.0, peak[0]-2.0, 0.5, 0.5, 0] maxpars=[0, 0, peak[1]+2.0, peak[0]+2.0, 2, 2, 180] params=[0, sp.data.max(), csize, csize, 2, 2, 10] if 'h2co' in cubename or 'ch3oh6' in cubename: maxpars[4] = 5 maxpars[5] = 5 params[4] = 4 (h,a,x,y,sx,sy,pa),gfim = gaussfitter.gaussfit(cutout.value, returnfitimage=True, params=params, limitedmin=limitedmin, limitedmax=limitedmax, minpars=minpars, maxpars=maxpars) print("Cube {0}: centroid = {1},{2} width={3},{4}".format(cubename, x, y, sx, sy)) residual = cutout.value - gfim noise = np.std(residual) (((h,a,x,y,sx,sy,pa), (dh,da,dx,dy,dsx,dsy, dpa)), gfim) = gaussfitter.gaussfit(cutout.value, returnfitimage=True, params=params, limitedmin=limitedmin, limitedmax=limitedmax, minpars=minpars, maxpars=maxpars, return_error=True, err=noise) print("Cube {0}: centroid = {1}+/-{dx}, {2}+/-{dy} width={3},{4} PA={5}".format(cubename, x, y, sx, sy, pa, dx=dx, dy=dy)) hdu = cutout.hdu
out = image p0 = 100. p1 = 256. p2 = 256. p3 = 15. p4 = 15.0 p5 = 2.0 p6 = 0. pFit, error = fit2dlibrary.fit_function( p0, image, fit2dlibrary.fitdict['Gaussian2Dphi'].function ) print pFit pstart = [patchcounts/box/box,braggsig, row, col, 5., 5., 0.] p, fitimg = gaussfitter.gaussfit( out, params=pstart, returnfitimage=True) # p = [height, amplitude, x, y, width_x, width_y, rotation] row = p[2] col = p[3] print "Sum of counts = %f" % image.sum() pngprefix = sys.argv[FITSFILE] + '_fits' falsecolor.inspecpng( [image, fitimg], row, col, out.min(), out.max(), \ falsecolor.my_grayscale, pngprefix, 100, origin = 'upper' , step=False, scale=10)