def get_point_state(point, rad, number, pixel_width):
positive = number // 2
if(positive == 1):
state = (number + 1) / 2
else:
state = -(number / 2)
return fit.get_point_at_distance(point, state, rad)
def get_angles_of(points):
size = len(points)
angles = np.zeros(size)
for i in range(size):
if(i==size-1):
p1, p2, p3 = points[i-1], points[i], points[0]
else:
p1, p2, p3 = points[i-1], points[i], points[i+1]
angles[i] = fit.get_normal_angle(p1, p2, p3)
return angles
def Fit() :
if W.verbose>0 :verbose =1
if (W.type["fit"]=="Gaussian2D"):
tmp = {"spread_y":W.suposed_param["spread_x"] , "theta":0.1 }
W.suposed_param.update( tmp )
elif(W.type["fit"]=='Gaussian'): pass
elif (W.type["fit"]=='Moffat'): # 1.5 = /np.sqrt(1/2**(-1/b)-1)
W.suposed_param.update( {'spread_x':1.5*my_fwhm,'exponent':2} )
elif (W.type["fit"]=="Moffat2D"): # 0.83 = sqrt(ln(2))
tmp = {"spread_y":W.suposed_param["spread_x"] , "theta":0.1 ,"exponent":2}
W.suposed_param.update( tmp )
elif (W.type["fit"]=='Bessel1'): pass
elif (W.type["fit"]=="Bessel12D"): # 0.83 = sqrt(ln(2))
tmp = {"spread_y":W.suposed_param["spread_x"] , "theta":0.1 }
W.suposed_param.update( tmp )
elif ("Gaussian_hole" in W.type["fit"]): # we consider 2D or not, same_center or not
W.suposed_param.update( { 'center_x_hole':x0,'center_y_hole':y0,'spread_x_hole':0.83*(my_fwhm)/2,'spread_y_hole':0.83*my_fwhm/2,'intensity_hole':0,'theta':0.1,'theta_hole':0.1} )
if not ("2D" in W.type["fit"]):
W.suposed_param["2D"]=0
doNotFit.append("theta"); doNotFit.append("theta_hole")
doNotFit.append("spread_y"); doNotFit.append("spread_y_hole")
else : W.suposed_param["2D"]=1
if ("same_center" in W.type["fit"]):
W.suposed_param["same_center"]=1
doNotFit.append("center_x_hole"); doNotFit.append("center_y_hole")
doNotFit.append("2D"); doNotFit.append("same_center")
# ACTUAL FIT
if W.type["fit"] != "None" :
res = FF.leastsqFit(vars(BF)[W.type["fit"]],(x,y),W.suposed_param,IX,err=eIX,doNotFit=doNotFit,bounds=James,verbose=verbose)
else :
restmp = {'center_x':x0,'center_y':y0,'intensity':my_max,"r99x":5*my_fwhm,"r99y":5*my_fwhm }
res= (restmp,0,0, IX,0 )
return res
def active_shape(edge_img,
tooth_points,
pca_tooth,
length,
alfa,
activeFitON,
MatchingON=True):
if (activeFitON):
new_points = af.active_contour(tooth_points, edge_img, length, alfa)
else:
new_points, error = fit.fit_measure(tooth_points, length, edge_img)
if (MatchingON):
b, pose_param = match.match_model_points(new_points, pca_tooth)
x = match.generate_model_point(b, pca_tooth)
y = match.inv_transform(x.reshape(40, 2), pose_param)
else:
y = new_points
return y
import Dispersion_ConstTheta
n_start = int(sys.argv[2])
n_stop = int(sys.argv[3])
#determine Type
result_A = [] ;
result_Theory = [] ;
ky = 0.
ky_list = 0.
for fileh_name in sys.argv[4:]:
try:
fileh5 = openFile(fileh_name)
ky, gamma = FitFunction.getGrowth(fileh5, pos=(n_start,n_stop))
gamma = array(gamma) #fileh5.root.Species[1]
result_A.append((gamma, fileh5.root.Geometry._v_attrs.Theta[0]))
#Setup = { 'eta_e' : 6., 'kx' : 0.0, 'v_te' : sqrt(2.), 'rho_te2' : 1., 'tau' : 1., 'theta' : 0. }
Setup = { 'eta' : 6., 'kx' : 0.0, 'v_te' : mp.sqrt(2.), 'rho_te2' : 1., 'tau' : 1., 'theta' : 0. , 'm_ie' : 1837., 'lambda_D2' : 0.}
Setup['theta'] = fileh5.root.Geometry._v_attrs.Theta[0]
ky_list = linspace(min(ky), min(max(ky),9999.), 151)
_disp="Gyro1st"
if(fileh5.root.Grid._v_attrs.Nm[0] > 1) : _disp="Gyro"
print _disp
print Setup['theta'], " " , _disp
kye, y, e = Dispersion_ConstTheta.getGrowth(ky_list, Setup, disp=_disp)
result_Theory.append((kye, y, e, Setup['theta']))
def TightBinaryPsf(grid,search=False): # slowlyer
"""search = True means we search the maximum """
########
#" FIRST GUESS
max0 = G.star1
max1 = G.star2
star_distance = np.sqrt( (max0[0]-max1[0])**2 + (max0[1]-max1[1])**2 ) # distance between two pooints
my_center = [(max0[0]+max1[0])/2 , (max0[1]+max1[1])/2 ]
dist0 = min( IF.FWHM(grid,max0) , star_distance /2 )
dist1 = min( IF.FWHM(grid,max1) , star_distance /2 )
###########
# make limits od fit
bd_x0 = (max0[0] - star_distance/2, max0[0] + star_distance/2 )
bd_y0 = (max0[1] - star_distance/2, max0[1] + star_distance/2 )
bd_x1 = (max1[0] - star_distance/2, max1[0] + star_distance/2 )
bd_y1 = (max1[1] - star_distance/2, max1[1] + star_distance/2 )
########
# DEFINE fitting space
fit_range = star_distance + 5 * max(dist0,dist1) # range of the fit
# the error
rx1,rx2= int(my_center[0] - fit_range/2) , int(my_center[0] + fit_range/2)
ry1,ry2 = int(my_center[1] - fit_range/2) , int(my_center[1] + fit_range/2)
if W.verbose>3:
print "----->IF.BinaryPSF :"
print "The fit is done between points ", (rx1,ry1)," and ", (rx2,ry2)
print "with fit", W.type["fit"]
X,Y=np.arange(int(rx1),int(rx2)+1),np.arange(int(ry1),int(ry2)+1)
y,x = np.meshgrid(Y,X)
IX=grid[rx1:rx2+1,ry1:ry2+1]
IX,mIX=IF.FindBadPixel(IX)#,r=r)
eIX = (IX-mIX).std()
eIX *= np.ones(IX.shape)
###################
## Supposed params and bounds #
###################
W.suposed_param={'x0':max0[0],'x1':max1[0],'y0':max0[1],'y1':max1[1],
'spread_x0':0.83*(dist0),'spread_x1':0.83*dist1,
'spread_y0':0.83*(dist0),'spread_y1':0.83*dist1,
'intensity0':grid[max0[0]][max0[1]],'intensity1':grid[max1[0]][max1[1]],
'background':0, "theta":1 }
cut1 = W.Im0 [G.star1[0]-2:G.star1[0]+2, G.star1[1]-2:G.star1[1]+2]
min1 = np.median(cut1)
max1 = np.max(cut1)
max1 = 2*max1 - min1
cut2 = W.Im0 [G.star2[0]-2:G.star2[0]+2, G.star2[1]-2:G.star2[1]+2]
min2 = np.median(cut2)
max2 = np.max(cut2)
max2 = 2*max2 - min2
James={
'x0':(G.star1[0]-2,G.star1[0]+2),
'x1':(G.star2[0]-2,G.star2[0]+2),
'y0':(G.star1[1]-2,G.star1[1]+2),
'y1':(G.star2[1]-2,G.star2[1]+2),
'spread_x0':(-0.1,None) ,
'spread_x1':(-0.1,None),
'spread_y0':(-0.1,None),
'spread_y1':(-0.1,None) ,
'intensity0':(min1,max1) ,
'intensity1':(min2,max2) ,
'background':(None,None) ,
"theta":(-0.1,3.24) } # becasue James Bound hahahah, These are the fitting limits of the varaibles . WARNING we put the intensity positive becasue in a binary fit situation you know.... who knows
###########
## DO NOT FIT, dic_for_fit
if "Bessel" in W.type["fit"] :
if W.verbose > 0 : print "WARNING : no bessel 2pt fit type now,fit type is set to gaussian"
W.type["fit"]="Gaussian"
if "Moffat" in W.type["fit"] :
W.suposed_param['b0'],W.suposed_param['b1']=1.8,1.8
James['b0']=(1,3) ; James['b1']=(1,3)
doNotFit = []
dic_for_fit = {"same_psf": W.same_psf,"aniso":0}
if "2D" in W.type["fit"] : dic_for_fit["aniso"]=1
if W.same_psf:
doNotFit.append("spread_x1")
doNotFit.append("spread_y1")
if not "2D" in W.type["fit"] :
doNotFit.append("spread_y0")
doNotFit.append("theta")
if "Moffat" in W.type["fit"] :
doNotFit.append("b1")
else : # not same psf
if not "2D" in W.type["fit"] :
doNotFit.append("spread_y0")
doNotFit.append("spread_y1")
doNotFit.append("theta")
##########
# PRINT
if W.verbose>3 : print "Binary FiT, supposed parameters : ", W.suposed_param
if W.verbose>3 : print "fit type is : " ,W.type["fit"]
if W.verbose>3 : print "anisoplanetism="+ str(bool(dic_for_fit["aniso"])),"same_psf="+str(bool(dic_for_fit["same_psf"]))
#####################
## FIT FIT ahora si que si
res = FF.leastsqFit(
lambda x,y: vars(BF)[W.type["fit"].replace("2D","")+"2pt"](x,y,dic=dic_for_fit),
(x,y),W.suposed_param,IX,
err=eIX,doNotFit=doNotFit,
bounds=James,
verbose = W.verbose>1,
)
##############
# Restore not fitted variables
def Restore(list,to_change,reference):
list[0][to_change] = list[0][reference]
list[1][to_change] = list[1][reference]
return list
if W.same_psf:
res = Restore(res,"spread_x1","spread_x0")
res = Restore(res,"spread_y1","spread_y0")
if not "2D" in W.type["fit"] :
res = Restore(res,"spread_y0","spread_x0")
if "Moffat" in W.type["fit"] :
res = Restore(res,"b1","b0")
else : # not same psf
if not "2D" in W.type["fit"] :
res = Restore(res,"spread_y0","spread_x0")
res = Restore(res,"spread_y1","spread_x1")
# BACKKUP DIC
tmp = {} ; tmp.update(res[0])
res[0]["fit_dic"]= tmp
# FWHM , Photo < from fit
dic_copy0 = res[0].copy()
dic_copy1 = res[0].copy()
for key in res[0].keys() :
if "0" in key :
dic_copy0[ key.replace("0","")] = dic_copy0[ key ]
elif "1" in key :
dic_copy1[ key.replace("1","")] = dic_copy1[ key ]
# nevermind the center x0 and x1
dic_copy0["exponent"] = dic_copy0["b0"]
dic_copy1["exponent"] = dic_copy1["b1"]
tmp = IF.FwhmFromFit( dic_copy0 , W.type["fit"] )
res[0].update( {"fwhm_x0":tmp["fwhm_x"] ,
"fwhm_y0":tmp["fwhm_y"] ,
"photometry_fit0":tmp["photometry_fit"] ,
} )
tmp = IF.FwhmFromFit( dic_copy1 , W.type["fit"] )
res[0].update( {"fwhm_x1":tmp["fwhm_x"] ,
"fwhm_y1":tmp["fwhm_y"] ,
"photometry_fit1":tmp["photometry_fit"]
} )
if False :
if "Gaussian" in W.type["fit"] :
if "2D" in W.type["fit"] :
photometry0= np.pi*res[0]['intensity0']*res[0]['spread_x0']*res[0]['spread_y0']
photometry1= np.pi*res[0]['intensity1']*res[0]['spread_x1']*res[0]['spread_y1']
else :
photometry0= np.pi*res[0]['intensity0']*res[0]['spread_x0']**2
photometry1= np.pi*res[0]['intensity1']*res[0]['spread_x1']**2
if "Moffat" in W.type["fit"] :
if "2D" in W.type["fit"] :
photometry0= np.pi*res[0]['intensity0']*res[0]['spread_x0']*res[0]['spread_y0']/(res[0]['b0']-1)
photometry1= np.pi*res[0]['intensity1']*res[0]['spread_x1']*res[0]['spread_y1']/(res[0]['b1']-1)
else :
photometry0= np.pi*res[0]['intensity0']*res[0]['spread_x0']**2/(res[0]['b0']-1)
photometry1= np.pi*res[0]['intensity1']*res[0]['spread_x1']**2/(res[0]['b1']-1)
if "hole" in W.type["fit"] : photometry-= np.pi*res[0]['intensity_hole']*res[0]['spread_x_hole']*res[0]['spread_y_hole']
res[0]['center_x'],res[0]['center_y']=my_center[0],my_center[1] # to draw
res[0]["photometry0"],res[0]["photometry1"]=photometry0,photometry1
res[0]["my_photometry0"],res[0]["my_photometry1"]= res[0]["photometry_fit0"],res[0]["photometry_fit1"]
return res
