class Stars:
'''
Stars
'''
def __init__(self):
self.path, fil = os.path.split(os.path.abspath(__file__))
self.win = gtk.Window()
self.win.set_size_request(800, 800)
self.win.set_title('Stars')
self.win.set_resizable(False)
self.win.set_events(self.win.get_events() | gtk.gdk.BUTTON_PRESS_MASK)
self.win.connect('destroy', gtk.main_quit)
self.fix = gtk.Fixed()
self.win.add(self.fix)
self.win.show_all()
img = gtk.Image()
img.set_from_file(self.path+'/img/star800.png')
img.show()
self.fix.put(img, 0, 0)
#Creating controller
self.controller = Controller()
star_status = self.controller.get_stars_status()
#Create all buttons here:
for i in range(1, star_coord.__len__() +1):
if i <= 53:
button = gtk.ToggleButton("%d"%i)
button.connect("toggled", self.callback, "%d"%i)
button.show()
self.fix.put(button, star_coord[i][0], star_coord[i][1])
self.default_style_toogle = button.get_modifier_style()
if star_status[i].__contains__('ON') is True:
button.set_active(True)
else:
pass
def callback(self, widget, data=None):
'''
callback
'''
print "%s was toggled %s" % (data, ("OFF", "ON")[widget.get_active()])
star = int(data)
map = widget.get_colormap()
color_on = map.alloc_color("red")
if widget.get_active() is True:
widget.modify_bg(gtk.STATE_ACTIVE, color_on)
try:
self.controller.star_on(star)
except Exception, e:
print e
else:
def __init__(self):
self.path, fil = os.path.split(os.path.abspath(__file__))
self.win = gtk.Window()
self.win.set_size_request(800, 800)
self.win.set_title('Stars')
self.win.set_resizable(False)
self.win.set_events(self.win.get_events() | gtk.gdk.BUTTON_PRESS_MASK)
self.win.connect('destroy', gtk.main_quit)
self.fix = gtk.Fixed()
self.win.add(self.fix)
self.win.show_all()
img = gtk.Image()
img.set_from_file(self.path+'/img/star800.png')
img.show()
self.fix.put(img, 0, 0)
#Creating controller
self.controller = Controller()
star_status = self.controller.get_stars_status()
#Create all buttons here:
for i in range(1, star_coord.__len__() +1):
if i <= 53:
button = gtk.ToggleButton("%d"%i)
button.connect("toggled", self.callback, "%d"%i)
button.show()
self.fix.put(button, star_coord[i][0], star_coord[i][1])
self.default_style_toogle = button.get_modifier_style()
if star_status[i].__contains__('ON') is True:
button.set_active(True)
else:
pass
def __init__(self,dir_name='slopes',camera='pike',server='corba'):
#Camera instance
self.Cam = Camera(camera)
#Darc Controller instance
self.c = darc.Control(self.Cam.name)
#Beagle Controller instance
self.bbbc = None
if server=='corba':
self.bbbc = Controller()
else:
self.bbbc = Controller(server=server)
#self.logger = logging.getLogger(__name__)
#Camera instance
self.Cam = Camera(camera)
#
self.niter = 5
self.image_path = self.Cam.image_path
self.dir_name = dir_name
self.cases = {'slopes':0,'images':1,'both':2}
def __init__(self,cameraName):
'''
INPUT
cameraName [string]
'''
#Darc Controller instance
self.c = darc.Control(cameraName)
#Beagle Controller instance
self.bbbc = Controller()
#Darc camera instance
self.Cam = Camera(cameraName)
#Parameters
self.niter = int(1)
self.nsubaps = int(self.Cam.nsubaps) # number of active subaps(208*2)
self.nsubaps *= 2
self.nstars = self.Cam.nstars # number of stars
self.maxexptime = float(self.Cam.maxexptime) # maximum exptime time. when exptime time is set outside
# the range [0:4095] it is taken as the modulus of tExptime/4095
self.sat = float(self.Cam.saturation) # self.Cam.name saturation value
self.majorpattern = None
self.minorpattern = None
class Acquisition:
def __init__(self,dir_name='slopes',camera='pike',server='corba'):
#Camera instance
self.Cam = Camera(camera)
#Darc Controller instance
self.c = darc.Control(self.Cam.name)
#Beagle Controller instance
self.bbbc = None
if server=='corba':
self.bbbc = Controller()
else:
self.bbbc = Controller(server=server)
#self.logger = logging.getLogger(__name__)
#Camera instance
self.Cam = Camera(camera)
#
self.niter = 5
self.image_path = self.Cam.image_path
self.dir_name = dir_name
self.cases = {'slopes':0,'images':1,'both':2}
def grab(self,stream,niter):
taken = pp.unpack(self.c.GetStreamBlock(self.Cam.name+stream,niter)).sum(0)/float(niter)
return taken
def grab_data_from_darc(self,acquire):
'''
Using darc, take a FITS image and save it into the disk. By default use
a <camera name>_<image prefix>_YEAR-MONTH-DAYTHOUR-MIN-SEC.fits as
image name. The path to be store the file as well as image_prefix can
be modified in configuration file
This should also take slopes (which will be used as training data)
'''
logging.info('About to take data with darc ...')
slope_stream = None
#Get slope_streams:
if(self.cases[acquire]==0):
slope_stream = self.grab('rtcCentBuf',self.niter)
logging.debug(slope_stream)
return slope_stream
elif(self.cases[acquire]==1):
slope_stream = self.grab('rtcCalPxlBuf',self.niter)
logging.debug(slope_stream)
return slope_stream
else:
print 'Can\'t acquire!'
return
def take_data(self, star_list, cmd_list,acquire):
'''
This method does:
After that, start all over again, given a number of times in num
variable
star_list is a Star object list
from BeagleDarc.Model import Star
star_list = []
for i in range(1,n+1):
star_list.append(Star(i))
'''
print 'Acquisition position: ',
print cmd_list
#Turning on a star to prevent noise
self.bbbc.star_on(1)
#horizontal motor move
self.bbbc.set_position('horizontal_altitude_layer',cmd_list[0], 200)
#vertical motor move
self.bbbc.set_position('vertical_altitude_layer',cmd_list[1], 200)
slopes_frame = None
images_frame = None
if(self.cases[acquire]==0):
slopes_frame = np.array([])
elif(self.cases[acquire]==1):
images_frame = np.array([])
elif(self.cases[acquire]==2):
slopes_frame = np.array([])
images_frame = np.array([])
# led on
self.bbbc.star_off(1)
for star in star_list:
star.setup(self.Cam)
self.bbbc.star_on(int(star.image_prefix))
#take img with darc
if(self.cases[acquire]==0):
slopes_frame = np.append(slopes_frame,self.grab_data_from_darc(acquire))
elif(self.cases[acquire]==1):
images_frame = np.append(images_frame,self.grab_data_from_darc(acquire))
elif(self.cases[acquire]==2):
slopes_frame = np.append(slopes_frame,self.grab_data_from_darc('slopes'))
images_frame = np.append(images_frame,self.grab_data_from_darc('images'))
#led off
self.bbbc.star_off(int(star.image_prefix))
if(self.cases[acquire]==0):
return slopes_frame
elif(self.cases[acquire]==1):
return images_frame
elif(self.cases[acquire]==2):
return (slopes_frame,images_frame)
return slopes_frame
def take_all_data(self,iterations,star_list,prefix,acquire='slopes',altitude=-1,fpf=10):
'''
fpf = frames per FITS.
smpling = steps per position
'''
Start_time = str(time.strftime("%Y_%m_%dT%H_%M_%S.fits", time.gmtime()))
#cali = Calibration(self.Cam.name)
#cali.routine_calibration(star_list)
# Comment this flush when calibrating
self.bbbc.flush_all_leds()
all_slopes = None
all_images = None
cmd_list = None
if(self.cases[acquire]==0):
all_slopes = np.zeros((fpf,len(star_list)*2*self.Cam.nsubaps))
elif(self.cases[acquire]==1):
all_images = np.zeros((fpf,len(star_list)*self.Cam.pxlx*self.Cam.pxly))
elif(self.cases[acquire]==2):
all_slopes = np.zeros((fpf,len(star_list)*2*self.Cam.nsubaps))
all_images = np.zeros((fpf,len(star_list)*self.Cam.pxlx*self.Cam.pxly))
else:
print 'Can\'t acquire!'
return
Star_list = []
cmd_list = self.cmdlist_gen(iterations,altitude)
for s in star_list:
Star_list.append(Star(s))
for i in range(0,int(iterations)):
Start_time = str(time.strftime("%Y_%m_%dT%H_%M_%S.fits", time.gmtime()))
print '\nTaking iteration #: %d' % (i+1)
if(self.cases[acquire]==0):
oli = self.take_data(Star_list, cmd_list[i],'slopes')
all_slopes[i%fpf,:] = oli
elif(self.cases[acquire]==1):
oli = self.take_data(Star_list, cmd_list[i],'images')
all_images[i%fpf,:] = oli
elif(self.cases[acquire]==2):
oli = self.take_data(Star_list, cmd_list[i],'both')
all_slopes[i%fpf,:] = oli[0]
all_images[i%fpf,:] = oli[1]
if((i+1)%fpf==0 or i==(iterations-1)):
if os.path.exists(self.image_path+self.dir_name) is False:
os.mkdir(self.image_path+self.dir_name)
slope_name = self.Cam.name + '_slopes_' + prefix + '_' +str(fpf).zfill(3) + '_T' +Start_time
image_name = self.Cam.name + '_images_' + prefix + '_' +str(fpf).zfill(3) + '_T' +Start_time
slp_path = os.path.normpath(self.image_path+self.dir_name+'/'+slope_name)
img_path = os.path.normpath(self.image_path+self.dir_name+'/'+image_name)
if(self.cases[acquire]==0):
FITS.Write(all_slopes.astype(np.float32), slp_path, writeMode='w')
elif(self.cases[acquire]==1):
FITS.Write(all_images.astype(np.float32), img_path, writeMode='w')
elif(self.cases[acquire]==2):
FITS.Write(all_slopes.astype(np.float32), slp_path, writeMode='w')
FITS.Write(all_images.astype(np.float32), img_path, writeMode='w')
logging.info('Data saved : %s' % slp_path)
Start_time = str(time.strftime("%Y_%m_%dT%H_%M_%S.fits", time.gmtime()))
if(self.cases[acquire]==0):
all_slopes = all_slopes*0.
elif(self.cases[acquire]==1):
all_images = all_images*0.
elif(self.cases[acquire]==2):
all_slopes = all_slopes*0.
all_images = all_images*0.
self.bbbc.flush_all_leds()
def cmdlist_gen(self,iterations,altitude=-1):
# Motor 0: horizontal
motorh = Layer('horizontal_altitude_layer')
# Motor 1: vertical
motorv = Layer('vertical_altitude_layer')
cmd_temp = []
cmd_list = []
cur_pos = [0,0]
mindis = motorh.vr_end + motorv.vr_end
minarg = 0
cmdx = []
cmdy = []
for cmd in range(0,int(iterations)):
if(altitude>=0.0 and altitude<=1.0):
cmd_temp = cmd_temp + [[int(motorh.vr_end*cmd/iterations),int(altitude*motorv.vr_end)]]
else:
cmd_temp = cmd_temp + [[random.randint(0,motorh.vr_end),random.randint(0,motorv.vr_end)]]
for it0 in range(0,int(iterations)):
for it1 in range(0,len(cmd_temp)):
if(mindis > (abs(cmd_temp[it1][0]-cur_pos[0])*0.5 + (cmd_temp[it1][1]-cur_pos[1]))):
mindis = abs(cmd_temp[it1][0]-cur_pos[0])*0.5 + (cmd_temp[it1][1]-cur_pos[1])
minarg = it1
cur_pos = cmd_temp.pop(minarg)
cmd_list = cmd_list + [cur_pos]
cmdx = cmdx + [cur_pos[0]]
cmdy = cmdy + [cur_pos[1]]
minarg = 0
mindis = motorh.vr_end + motorv.vr_end
#plt.plot(cmdx,cmdy,'k')
#plt.show()
return cmd_list
def first_calibration(self,star_list):
cali = Calibration(self.Cam.camera)
cali.first_calibration(star_list)
def __init__(self):
self.path, fil = os.path.split(os.path.abspath(__file__))
self.win = gtk.Window()
self.win.set_size_request(800, 800)
self.win.set_title('Layers')
self.win.set_resizable(False)
self.win.set_events(self.win.get_events() | gtk.gdk.BUTTON_PRESS_MASK)
self.win.connect('destroy', gtk.main_quit)
self.fix = gtk.Fixed()
self.win.add(self.fix)
self.win.show_all()
### LED POSITION ###
# ground: sts init
self.sts_ground_init = gtk.Image()
self.sts_ground_init.set_from_file(self.path+'/img/led-green.gif')
self.fix.put(self.sts_ground_init, 135, 695)
self.sts_ground_init.show()
# ground: sts end
self.sts_ground_end = gtk.Image()
self.sts_ground_end.set_from_file(self.path+'/img/led-green.gif')
self.fix.put(self.sts_ground_end, 650, 695)
self.sts_ground_end.show()
# altitude X : sts init
self.sts_altitude_X_init = gtk.Image()
self.sts_altitude_X_init.set_from_file(self.path+'/img/led-green.gif')
self.fix.put(self.sts_altitude_X_init, 135, 615)
self.sts_altitude_X_init.show()
# altitude X : sts end
self.sts_altitude_X_end = gtk.Image()
self.sts_altitude_X_end.set_from_file(self.path+'/img/led-green.gif')
self.fix.put(self.sts_altitude_X_end, 650, 615)
self.sts_altitude_X_end.show()
# altitude Y : sts init
self.sts_altitude_Y_init = gtk.Image()
self.sts_altitude_Y_init.set_from_file(self.path+'/img/led-green.gif')
self.fix.put(self.sts_altitude_Y_init, 705, 15)
self.sts_altitude_Y_init.show()
# altitude Y : sts end
self.sts_altitude_Y_end = gtk.Image()
self.sts_altitude_Y_end.set_from_file(self.path+'/img/led-green.gif')
self.fix.put(self.sts_altitude_Y_end, 705, 490)
self.sts_altitude_Y_end.show()
### Layer IMG ###
# ground: cur
self.img_ground_cur = gtk.Image()
self.img_ground_cur.set_from_file(self.path+'/img/gl_full_s.png')
self.fix.put(self.img_ground_cur, 100, 500)
self.img_ground_cur.show()
# ground: cmd
self.img_ground_cmd = gtk.Image()
self.img_ground_cmd.set_from_file(self.path+'/img/al_empty_s.png')
self.fix.put(self.img_ground_cmd, 100, 500)
self.img_ground_cmd.show()
# altitude: cur
self.img_altitude_cur = gtk.Image()
self.img_altitude_cur.set_from_file(self.path+'/img/al_full_s.png')
self.fix.put(self.img_altitude_cur, 100, 450)
self.img_altitude_cur.show()
# altitude: cmd
self.img_altitude_cmd = gtk.Image()
self.img_altitude_cmd.set_from_file(self.path+'/img/al_empty_s.png')
self.fix.put(self.img_altitude_cmd, 100, 450)
self.img_altitude_cmd.show()
############ labels ##########
self.label1 = gtk.Label()
self.label1.modify_font(pango.FontDescription("sans 8"))
self.label1.set_text("Ground Layer")
self.label1.show()
self.fix.put(self.label1, 350, 680)
self.label2 = gtk.Label()
self.label2.modify_font(pango.FontDescription("sans 8"))
self.label2.set_text("Altitude Layer X")
self.label2.show()
self.fix.put(self.label2, 350, 600)
self.label3 = gtk.Label()
self.label3.modify_font(pango.FontDescription("sans 8"))
self.label3.set_angle(90)
self.label3.set_text("Altitude Layer Y")
self.label3.show()
self.fix.put(self.label3, 690, 200)
self.label4 = gtk.Label()
self.label4.modify_font(pango.FontDescription("sans 8"))
self.label4.set_text("Y: INIT POSITION")
self.label4.show()
self.fix.put(self.label4, 570, 470)
self.label5 = gtk.Label()
self.label5.modify_font(pango.FontDescription("sans 8"))
self.label5.set_text("Y: END POSITION")
self.label5.show()
self.fix.put(self.label5, 570, 50)
self.label6 = gtk.Label()
self.label6.modify_font(pango.FontDescription("sans 8"))
self.label6.set_text("X: INIT POSITION")
self.label6.show()
self.fix.put(self.label6, 5, 540)
self.label7 = gtk.Label()
self.label7.modify_font(pango.FontDescription("sans 8"))
self.label7.set_text("X: END POSITION")
self.label7.show()
self.fix.put(self.label7, 570, 540)
#ground x
self.label8 = gtk.Label()
self.label8.modify_font(pango.FontDescription("sans 8"))
self.label8.set_text("position")
self.label8.show()
self.fix.put(self.label8, 75, 700)
#
self.label9 = gtk.Label()
self.label9.modify_font(pango.FontDescription("sans 8"))
self.label9.set_text("velocity")
self.label9.show()
self.fix.put(self.label9, 75, 715)
#altitude x
self.label10 = gtk.Label()
self.label10.modify_font(pango.FontDescription("sans 8"))
self.label10.set_text("position")
self.label10.show()
self.fix.put(self.label10, 75, 620)
#
self.label11 = gtk.Label()
self.label11.modify_font(pango.FontDescription("sans 8"))
self.label11.set_text("velocity")
self.label11.show()
self.fix.put(self.label11, 75, 635)
#altitude y
self.label12 = gtk.Label()
self.label12.modify_font(pango.FontDescription("sans 8"))
self.label12.set_angle(90)
self.label12.set_text("position")
self.label12.show()
self.fix.put(self.label12, 705, 510)
#
self.label13 = gtk.Label()
self.label13.modify_font(pango.FontDescription("sans 8"))
self.label13.set_angle(90)
self.label13.set_text("velocity")
self.label13.show()
self.fix.put(self.label13, 725, 510)
# POSITION BAR
########################
# ground_scale (pos)
#
layer = Layer('ground_layer')
adjustment = gtk.Adjustment(value=float(layer.cur_pos), lower=layer.vr_init, upper=layer.vr_end+1, step_incr=0.1, page_incr=1.0, page_size=1.0)
self.ground_scale_pos = gtk.HScale(adjustment)
self.ground_scale_pos.set_digits(0)
self.ground_scale_pos.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.ground_scale_pos.connect("value-changed", self.ground_scale_pos_moved)
self.ground_scale_pos.set_size_request(500, 30)
self.ground_scale_pos.show()
self.fix.put(self.ground_scale_pos, 150, 680)
########################
# ground_scale (vel)
#
adjustment = gtk.Adjustment(value=0.0, lower=0.0, upper=101.0, step_incr=0.1, page_incr=1.0, page_size=1.0)
self.ground_scale_vel = gtk.HScale(adjustment)
self.ground_scale_vel.set_digits(0)
self.ground_scale_vel.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.ground_scale_vel.connect("value-changed", self.ground_scale_vel_moved)
self.ground_scale_vel.set_size_request(500, 30)
self.ground_scale_vel.show()
self.fix.put(self.ground_scale_vel, 150, 700)
########################
# altitude_scale X (pos)
#
layer = Layer('horizontal_altitude_layer')
adjustment = gtk.Adjustment(value=float(layer.cur_pos), lower=layer.vr_init, upper=layer.vr_end+1, step_incr=0.1, page_incr=1.0, page_size=1.0)
self.altitude_scale_pos_X = gtk.HScale(adjustment)
self.altitude_scale_pos_X.set_digits(0)
self.altitude_scale_pos_X.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.altitude_scale_pos_X.connect("value-changed", self.altitude_scale_pos_X_moved)
self.altitude_scale_pos_X.set_size_request(500, 30)
self.altitude_scale_pos_X.show()
self.fix.put(self.altitude_scale_pos_X, 150, 600)
########################
# altitude_scale X (vel)
#
adjustment = gtk.Adjustment(value=0.0, lower=0.0, upper=101.0, step_incr=0.1, page_incr=1.0, page_size=1.0)
self.altitude_scale_vel_X = gtk.HScale(adjustment)
self.altitude_scale_vel_X.set_digits(0)
self.altitude_scale_vel_X.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.altitude_scale_vel_X.connect("value-changed", self.altitude_scale_vel_X_moved)
self.altitude_scale_vel_X.set_size_request(500, 30)
self.altitude_scale_vel_X.show()
self.fix.put(self.altitude_scale_vel_X, 150, 620)
########################
# altitude_scale Y (pos)
#
layer = Layer('vertical_altitude_layer')
adjustment = gtk.Adjustment(value=float(layer.cur_pos), lower=layer.vr_init, upper=layer.vr_end+1, step_incr=0.1, page_incr=1.0, page_size=1.0)
self.altitude_scale_pos_Y = gtk.VScale(adjustment)
self.altitude_scale_pos_Y.set_digits(0)
#self.altitude_scale_pos_Y.set_value_pos(gtk.POS_BOTTOM)
self.altitude_scale_pos_Y.set_inverted(True)
self.altitude_scale_pos_Y.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.altitude_scale_pos_Y.connect("value-changed", self.altitude_scale_pos_Y_moved)
self.altitude_scale_pos_Y.set_size_request(30, 450)
self.altitude_scale_pos_Y.show()
self.fix.put(self.altitude_scale_pos_Y, 700, 40)
########################
# altitude_scale Y (vel)
#
adjustment = gtk.Adjustment(value=0.0, lower=0.0, upper=101.0, step_incr=0.1, page_incr=1.0, page_size=1.0)
self.altitude_scale_vel_Y = gtk.VScale(adjustment)
self.altitude_scale_vel_Y.set_digits(0)
#self.altitude_scale_vel_Y.set_value_pos(gtk.POS_BOTTOM)
self.altitude_scale_vel_Y.set_inverted(True)
self.altitude_scale_vel_Y.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.altitude_scale_vel_Y.connect("value-changed", self.altitude_scale_vel_Y_moved)
self.altitude_scale_vel_Y.set_size_request(30, 450)
self.altitude_scale_vel_Y.show()
self.fix.put(self.altitude_scale_vel_Y, 720, 40)
# Apply button:
self.button_ok = gtk.Button("Execute Now")
self.button_ok.show()
self.button_ok.connect("clicked", self.execute_now)
self.fix.put(self.button_ok, 650, 750)
# EMERGENCY Button:
self.button_emergency = gtk.Button("EMERGENCY")
self.button_emergency.show()
self.button_emergency.connect("clicked", self.abort)
self.fix.put(self.button_emergency, 100, 750)
##Creating controller
self.controller = Controller()
## cmd pos/vel
self.ground_pos = self.controller.get_motor_cur_pos('ground_layer')
self.alt_x_pos = self.controller.get_motor_cur_pos('horizontal_altitude_layer')
self.alt_y_pos = self.controller.get_motor_cur_pos('vertical_altitude_layer')
print "server->ground_pos %.0f" % self.ground_pos
print "server->alt_x_pos %.0f" % self.alt_x_pos
print "server->alt_y_pos %.0f" % self.alt_y_pos
print "------------"
self.ground_vel = 0.0
self.alt_x_vel = 0.0
self.alt_y_vel = 0.0
# moving according
self.fix.move(self.img_ground_cur, 100+int(self.ground_pos*(3/200.)), 500)
self.fix.move(self.img_ground_cmd, 100+int(self.ground_pos*(3/200.)), 500)
self.fix.move(self.img_altitude_cur, 100+int(self.alt_x_pos*(4/200.)), 450 - int(self.alt_y_pos*(4/200.)))
self.fix.move(self.img_altitude_cmd, 100+int(self.alt_x_pos*(4/200.)), 450 - int(self.alt_y_pos*(4/200.)))
self.fix.move(self.img_altitude_cur, 100+int(self.alt_x_pos*(4/200.)), 450 - int(self.alt_y_pos*(4/200.)))
self.fix.move(self.img_altitude_cmd, 100+int(self.alt_x_pos*(4/200.)), 450 - int(self.alt_y_pos*(4/200.)))
from BeagleDarc.Controller import Controller
import ConfigParser
bbbc = Controller()
for s in range(1,54+1):
try:
print "s->%d on" % s
bbbc.star_on(s)
print "s->%d off" % s
bbbc.star_off(s)
except ConfigParser.NoSectionError:
pass
class Calibration:
def __init__(self,cameraName):
'''
INPUT
cameraName [string]
'''
#Darc Controller instance
self.c = darc.Control(cameraName)
#Beagle Controller instance
self.bbbc = Controller()
#Darc camera instance
self.Cam = Camera(cameraName)
#Parameters
self.niter = int(1)
self.nsubaps = int(self.Cam.nsubaps) # number of active subaps(208*2)
self.nsubaps *= 2
self.nstars = self.Cam.nstars # number of stars
self.maxexptime = float(self.Cam.maxexptime) # maximum exptime time. when exptime time is set outside
# the range [0:4095] it is taken as the modulus of tExptime/4095
self.sat = float(self.Cam.saturation) # self.Cam.name saturation value
self.majorpattern = None
self.minorpattern = None
def Set_useBrightest(self):
'''
#1- Setting useBrightest, loaded from the config. file.
'''
#self.c.Set('useBrightest',2*float(self.Cam.usebrightest))
self.c.Set('useBrightest',0)
def find_useBrightest(self):
self.bgImage_exptime_calibration(1)
self.subap_calibration(1)
hardniter = 100
nBrightest = 100 # range of values
# to test
noise = numpy.zeros(nBrightest)
name = self.Cam.name
frames = numpy.zeros([hardniter,self.nsubaps])
self.bbbc.star_on(1)
for i in range(0,nBrightest):
print '\nRecording with useBrightest:%3.0f ' %i
self.c.Set('useBrightest',-i)
cent = self.c.GetStreamBlock(name+'rtcCentBuf',hardniter) # hardniter frames - as a dict
cent = cent[cent.keys()[0]]
for j in range(0,hardniter):
frames[j,:] = cent[j][0]
centx2 = numpy.square(frames[:,::2])
centy2 = numpy.square(frames[:,1::2])
noise[i] = ((centx2+centy2).sum(0)/float(hardniter)).sum(0)/float(self.nsubaps) #
print noise.argmin(0)
self.c.Set('useBrightest',-float(noise.argmin(0)))
self.Cam.usebrightest = -int(noise.argmin(0))
pylab.plot(noise)
pylab.show()
self.bbbc.star_off(1)
#FITS.Write(noise.astype(numpy.float32),'noise_vs_useBrightest.fits')
def find_slope_niter():
stream = 'rtcCentBuf'
threshold = 1.0
for star_id in range(1,1+nstars):
star = Star(star_id)
ok = star.setup(self.Cam)
if(ok):
slope_niter = find_niter(stream,threshold)
if(slope_niter[0] != -1):
star.slope_iter = slope_niter[0]
FITS.Write(slope_niter[1],self.Cam.rawdata_path + self.Cam.name+'_slopes_noscreen_led_%d.fits'%(star_id),writeMode='a')
else:
print 'Relax threshold'
def find_bg_niter():
stream = 'rtcPxlBuf'
threshold = 10
c.Set('exptime',self.Cam.maxexptime)
bg_niter = find_niter(stream,threshold)
if(bg_iter[0] != -1):
self.Cam.bg_niter = bg_niter[0]
FITS.Write(bg_niter[1],self.Cam.rawdata_path + self.Cam.name+'_bgImage_exptime_%d.fits'%(int(self.Cam.maxexptime)),writeMode='a')
else:
print 'Relax threshold'
def find_niter(self,stream, threshold):
'''
Finds and store (with Norman's help) a reasonable number of
iterations to use when grabbing slopes or backgrounds.
The result is as small as possible given a wanted variance
under 1 pxl for slopes.
INPUT
stream[str] Name of the darc stream for which you
want to find the correct number of iterations
threshold[float] Threshold under which you want the noise
of your system to be (variance).
'''
harniter = 10000
subniter = 200
threshold = float(threshold)
slopes = numpy.zeros([hardniter,nsubaps])
runningnoise = numpy.zeros(subniter)
found = False
index_found = 0
print 'Stream Block Acquisition'
cent = self.c.GetStreamBlock(name+stream,hardniter) # hardniter frames - as a dict
print 'Extracting data'
cent = cent[cent.keys()[0]]
for j in range(0,hardniter):
slopes[j,:] = cent[j][0]
print 'Reducing data'
for n in numpy.arange(1,subniter+1):
runningnoise[n-1] = running_var(slopes,0,n)
if(runningnoise<=threshold and not(found)):
found = True
index_found = n
if(found):
return [index_found, slopes]
else:
return -1
print 'Number of iterations not found'
def running_var(self,data,axis,n):
'''
Shuffles data and calculates the mean along the specified axis.
The mean is calculated for sets of n samples. The variance is
calculated upon the resulting set of mean numbers. If data is
2-dimensional the output is the maximum resulting value.
INPUT
data[numpy array] Array of up to 2 dimensions
axis[int]
n[int]
OUTPUT
var[numpy float]
'''
# First we shuffle in the axis direction
if(axis==1):
data = numpy.transpose(data)
shape = numpy.shape(data)
if(numpy.shape(shape)[0]==1):
data = data.reshape((numpy.shape(data)[0],1))
elif(numpy.shape(shape)[0]>2):
raise DimError('data has more than 2 dimensions')
large = int(numpy.shape(data)[0]/n)
data = data[0:large,:]
shape = numpy.shape(data)
means = numpy.zeros((large,shape[1]))
for i in numpy.arange(0,shape[1]):
numpy.random.shuffle(data[:,i])
for j in numpy.arange(0,large):
means[j,i] = numpy.mean(data[j*n:(j+1)*n,i])
return numpy.amax(numpy.var(means,0))
def bgImage_exptime_calibration(self,star_id):
'''
Determines, sets and save the bgImage for star_id. exptime is
saved on the files name.
INPUT
star_id[int]
'''
#2-3 bgImage & exptime iteration
star = Star(star_id)
star.setup(self.Cam)
exptime = numpy.round(self.Cam.initexptime)
self.c.Set('bgImage',None)
self.c.Set(self.Cam.exptime,int(exptime))
bgImage = self.grab('rtcPxlBuf',self.niter)
self.c.Set('bgImage',bgImage)
self.bbbc.star_on(star_id)
auxImage = self.grab('rtcCalPxlBuf',self.niter)
self.bbbc.star_off(star_id)
auxImageMax = auxImage.max()
print 'auxImageMax: ', auxImageMax
relativemax = 0.7
threshold = 0.05
while(numpy.absolute(auxImageMax/self.sat-relativemax)>threshold):
# The while condition is set so that the maximum value found in the image
# is around 60% of the saturation value
print "exptime: ",
print exptime
print 'auxImageMax: ',
print str(100*auxImageMax/self.sat)+'%'
exptime = float(exptime)*(self.sat*float(relativemax))/auxImageMax
if(exptime>=self.maxexptime):
# Protection
exptime = self.maxexptime
auxImageMax = self.sat*relativemax
self.c.Set(self.Cam.exptime,int(exptime))
elif(exptime<1.0):
exptime = 1.0
auxImageMax = self.sat*relativemax
self.c.Set(self.Cam.exptime,int(exptime))
else:
self.c.Set('bgImage',None)
self.c.Set(self.Cam.exptime,int(exptime))
bgImage = self.grab('rtcPxlBuf',self.niter)
self.c.Set('bgImage',bgImage)
self.bbbc.star_on(star_id)
auxImage = self.grab('rtcCalPxlBuf',self.niter)
self.bbbc.star_off(star_id)
auxImageMax = numpy.amax(auxImage)
print "Final exptime: ",
print exptime
print 'Final auxImageMax: ',
print str(100*auxImageMax/self.sat)+'%'
self.c.Set('bgImage',None)
bgImage = self.grab('rtcPxlBuf',self.Cam.bg_iter)
self.c.Set('bgImage',bgImage)
self.bbbc.flush_all_leds()
self.bbbc.star_on(star_id)
auxImage = self.grab('rtcCalPxlBuf',self.niter)
self.bbbc.star_off(star_id)
self.c.Set('bgImage',bgImage)
#Saving values found and removing previous values
files = os.listdir(self.Cam.bg_path)
files = [s for s in files if 'led_%d_'%(star_id) in s]
if(files!=[]):
for file_name in files:
os.remove(self.Cam.bg_path + file_name)
FITS.Write(bgImage,self.Cam.bg_path + self.Cam.name+'_bg_led_%d_exptime_%d.fits'%(star_id,int(exptime)),writeMode='w')
FITS.Write(auxImage.reshape((self.Cam.pxly,self.Cam.pxlx)),self.Cam.bg_path + self.Cam.name+'_aux_led_%d_exptime_%d.fits'%(star_id,int(exptime)),writeMode='w')
def pupil_location(self,star_id):
#Parameters
self.c.Set('bgImage',None)
allsubaps = self.Cam.allsubaps # Active+Inactive subaps
side = int(numpy.sqrt(allsubaps))
nstars = self.Cam.nstars
subapLocation = numpy.zeros((allsubaps,6)) # Centred on (0,0)
subapLocation[:,2] = subapLocation[:,2] + 1
subapLocation[:,5] = subapLocation[:,5] + 1
Xwidth = self.Cam.xwidth
Ywidth = self.Cam.ywidth
Xgap = self.Cam.xgap
Ygap = self.Cam.ygap
# Checking for parity
xRow = numpy.array([])
if(side%2):
xRow = numpy.arange(-numpy.ceil(float(side)/2),round(float(side)/2))*Xgap -round(Xwidth/2)
else:
xRow = numpy.arange(-float(side)/2,float(side)/2)*Xgap + round(Xgap/2) -round(Xwidth/2)
yRow = numpy.array([])
if(side%2):
yRow = numpy.arange(-numpy.ceil(float(side)/2),round(float(side)/2))*Ygap -round(Ywidth/2)
else:
yRow = numpy.arange(-float(side)/2,float(side)/2)*Ygap + round(Ygap/2) -round(Ywidth/2)
for row in range(1,int(side+1)):
subapLocation[side*(row-1):side*(row),0] = yRow[row-1]
subapLocation[side*(row-1):side*(row),1] = subapLocation[side*(row-1):side*(row),0] + Ywidth
subapLocation[side*(row-1):side*(row),3] = xRow
subapLocation[side*(row-1):side*(row),4] = subapLocation[side*(row-1):side*(row),3] + Xwidth
if(self.majorpattern==None):
self.majorpattern = numpy.zeros((-subapLocation[0,0]+subapLocation[-1,1]+1,-subapLocation[0,3]+subapLocation[-1,4]+1))
self.minorpattern = numpy.zeros((Ywidth+1,Xwidth+1))
centx = float(Xwidth+1)/2 - 0.5
centy = float(Ywidth+1)/2 - 0.5
fwhm = self.Cam.fwhm
subapLocAux = subapLocation
Aux = numpy.zeros((allsubaps,6))
Aux[:,0:2] = subapLocAux[:,0:2] - subapLocation[0,0]
Aux[:,3:5] = subapLocAux[:,3:5] - subapLocation[0,3]
subapflag = FITS.Read(self.Cam.subapflag)[1]
subapflag = subapflag.ravel()
for y in range(0,Ywidth):
for x in range(0,Xwidth):
self.minorpattern[y,x] = numpy.exp(-(pow(x-centx,2)+pow(y-centy,2))/(2*pow(fwhm/2.35482,2)))
tracker = 0
for subap in Aux:
if(int(subapflag[tracker])):
self.majorpattern[subap[0]:subap[1]+1,subap[3]:subap[4]+1] += self.minorpattern
tracker += 1
patternshape = self.majorpattern.shape
self.bbbc.star_on(star_id)
s = Star(star_id)
#image = self.grab('rtcCalPxlBuf',s.slope_iter)
image = self.grab('rtcCalPxlBuf',1)
image = image.reshape((self.Cam.pxly,self.Cam.pxlx))
correlation = scipy.signal.fftconvolve(image,self.majorpattern,mode='same')
argmx = numpy.unravel_index(correlation.argmax(),correlation.shape)
print 'Pupil centre for star %d: '%(star_id),
print [argmx[1],argmx[0]]
print subapLocation[5,3]
subapLocation[:,0:2] += argmx[0]
subapLocation[:,3:5] += argmx[1]
print subapLocation[5,3]
#Saving values found and removing previous values
files = os.listdir(self.Cam.subaplocation_path)
files = [st for st in files if 'led_%d.fits'%(star_id) in st]
if(files!=[]):
for file_name in files:
os.remove(self.Cam.subaplocation_path + file_name)
FITS.Write(subapLocation,self.Cam.subaplocation_path + self.Cam.name+'_subapLocation_led_%d.fits'%(star_id),writeMode='w')
FITS.Write(image,self.Cam.subaplocation_path + 'image_%d.fits'%(star_id),writeMode='w')
FITS.Write(correlation,self.Cam.subaplocation_path + 'correlation_%d.fits'%(star_id),writeMode='w')
FITS.Write(self.majorpattern,self.Cam.subaplocation_path + 'major.fits',writeMode='w')
FITS.Write(self.minorpattern,self.Cam.subaplocation_path + 'minor.fits',writeMode='w')
self.bbbc.star_off(star_id)
subapflag = FITS.Read(self.Cam.subapflag)[1]
subapflag = subapflag.ravel()
v = subapflag.argmax()
print '1st subap centre for star %d: '%(star_id),
print [v,(subapLocation[v,3]+subapLocation[v,4])/2,(subapLocation[v,0]+subapLocation[v,1])/2]
#return subapLocation
def subap_calibration(self,star_id):
'''
Calibrates the subaps location for star_id
using an existing subap location. Finds reference
centroids.
INPUT
star_id[int]
'''
#4- Subaps
self.bbbc.star_on(star_id)
s = Star(star_id)
if(s.valid):
subapLocation = FITS.Read(self.Cam.subaplocation_path + self.Cam.name+'_subapLocation_led_%d.fits'%(star_id))[1]
self.c.Set('subapLocation',subapLocation.astype(numpy.float32))
self.c.Set("refCentroids",None)
cent = self.grab('rtcCentBuf',s.slope_iter)
subapLocation[:,3:5] += round(cent[::2].mean())
subapLocation[:,0:2] += round(cent[1::2].mean())
print '\nX subap correction: ',
print round(cent[::2].mean())
print 'Y subap correction: ',
print round(cent[1::2].mean())
#Saving values found and removing previous values
files = os.listdir(self.Cam.subaplocation_path)
files = [st for st in files if 'led_%d.fits'%(star_id) in st]
if(files!=[]):
for file_name in files:
os.remove(self.Cam.subaplocation_path + file_name)
FITS.Write(subapLocation.astype(numpy.float32),self.Cam.subaplocation_path + self.Cam.name+'_subapLocation_led_%d.fits'%(star_id),writeMode='a')
#5- Ref Cent
self.c.Set('subapLocation',subapLocation.astype(numpy.float32))
cent = self.grab('rtcCentBuf',s.slope_iter)
#Saving values found and removing previous values
files = os.listdir(self.Cam.refcent_path)
files = [st for st in files if 'led_%d.fits'%(star_id) in st]
if(files!=[]):
for file_name in files:
os.remove(self.Cam.refcent_path + file_name)
FITS.Write(cent.astype(numpy.float32),self.Cam.refcent_path+self.Cam.name+'_RefCent_led_%d.fits'%(star_id),writeMode='a')
self.c.Set('refCentroids',cent.astype(numpy.float32))
else:
print 'No subaps for led_%d'%(star_id)
self.bbbc.star_off(star_id)
def routine_calibration(self,star_list):
'''
Calibrates useBrightest, backgrounds and exptime times
for given stars
'''
#Main loop. Calibrates for each star
self.bbbc.set_position('horizontal_altitude_layer',-10000,200)
#First we flush
print 'Flushing!'
self.bbbc.flush_all_leds()
print 'Done flushing.\nBg acquisition...'
self.Set_useBrightest()
for star_id in star_list:
estrella = Star(star_id)
if(estrella.valid):
print '\nCalibrating star:%3.0f ' %star_id
self.bgImage_exptime_calibration(star_id)
def first_calibration(self,star_list):
'''
Calibrates useBrightest, backgrounds, exptime times,
subap locations and reference centroids for given stars
'''
#Main loop. Calibrates for each star
#First we flush
self.bbbc.flush_all_leds()
self.Set_useBrightest()
for star_id in star_list:
estrella = Star(star_id)
if(estrella.valid):
print '\nCalibrating star:%3.0f ' %star_id
self.pupil_location(star_id)
self.subap_calibration(star_id)
self.bgImage_exptime_calibration(star_id)
raw_input('First calibration concluded.\nSet phase screen and press enter to continue')
def grab(self,stream,niter):
taken = pp.unpack(self.c.GetStreamBlock(self.Cam.name+stream,niter)).sum(0)/float(niter)
return taken
