def __init__(self, cl, name):
PyTango.Device_4Impl.__init__(self, cl, name)
self.init_device()
self.__FillMode = {'ON': True, 'OFF': False}
self.__ThresholdGain = {
'DEFAULT': 0,
'LOW': 1,
'MID': 2,
'HIGH': 3,
'ULTRA HIGH': 4
}
self.__CamStatus = {
'ERROR': 0,
'DISCONNECTED': 1,
'STANDBY': 2,
'SETTING_ENERGY': 3,
'SETTING_THRESHOLD': 4,
'SETTING_EXPOSURE': 5,
'SETTING_NB_IMAGE_IN_SEQUENCE': 6,
'SETTING_EXPOSURE_PERIOD': 7,
'SETTING_HARDWARE_TRIGGER_DELAY': 8,
'SETTING_EXPOSURE_PER_FRAME': 9,
'SETTING_ROI': 10,
'KILL_ACQUISITION': 11,
'RUNNING': 12,
'ANYCMD': 13
}
self.__ReadoutRoi = {
'C60': Core.Roi(0, 0, 0, 0), #Full frame for 6M (0,0,2463,2527)
'C2': Core.Roi(988, 1060, 487, 407), #C2 for 6M
'C18': Core.Roi(494, 636, 1475, 1255) #C18 for 6M
}
def DevCcdSetRoI(self, argin):
roi = Core.Roi(Core.Point(argin[0], argin[1]), Core.Point(argin[2], argin[3]))
control = _control_ref()
image = control.image()
if roi == self.getMaxRoi() :
roi = Core.Roi()
image.setRoi(roi)
def getMaxRoi(self):
control = _control_ref()
ct_image = control.image()
max_roi_size = ct_image.getMaxImageSize()
max_roi_size /= Core.Point(ct_image.getBin())
max_roi = Core.Roi(Core.Point(0, 0), max_roi_size)
return max_roi
def __get_roi_list_from_argin(self, argin):
rois = []
for x, y, w, h in itertools.izip(
itertools.islice(argin, 0, len(argin), 4),
itertools.islice(argin, 1, len(argin), 4),
itertools.islice(argin, 2, len(argin), 4),
itertools.islice(argin, 3, len(argin), 4)):
roi = Core.Roi(x, y, w, h)
rois.append(roi)
return rois
def write_Roi(self, attr):
data = attr.get_write_value()
state = self.dev_state()
self.Stop()
roi = Core.Roi()
roi.setTopLeft(Core.Point(data[0], data[1]))
roi.setSize(Core.Size(data[2], data[3]))
self.image.setRoi(roi)
if state == PyTango.DevState.ON: self.Start()
def test_slsdetector_control(config_fname, enable_debug, use_events,
print_time, sleep_time, all_frames):
if enable_debug:
Core.DebParams.enableModuleFlags(Core.DebParams.AllFlags)
Core.DebParams.enableTypeFlags(Core.DebParams.AllFlags)
else:
Core.DebParams.disableModuleFlags(Core.DebParams.AllFlags)
deb.Always("Creating SlsDetectorAcq")
acq = SlsDetectorAcq(config_fname, use_events, print_time, sleep_time,
all_frames)
deb.Always("Done!")
acq.initSaving("data", "img", ".edf", 0, Core.CtSaving.EDF,
Core.CtSaving.AutoFrame, 1)
deb.Always("First run with default pars")
acq.run()
deb.Always("Done!")
exp_time = 100e-3
acq.setExpTime(exp_time)
nb_acq_frames = 50
acq.setNbAcqFrames(nb_acq_frames)
deb.Always("Run exp_time=%s, nb_acq_frames=%s" % (exp_time, nb_acq_frames))
acq.run()
deb.Always("Done!")
bin = Core.Bin(2, 2)
acq.setBin(bin)
nb_acq_frames = 5
acq.setNbAcqFrames(nb_acq_frames)
deb.Always("Run bin=<%sx%s>, nb_acq_frames=%s" %
(bin.getX(), bin.getY(), nb_acq_frames))
acq.run()
deb.Always("Done!")
roi = Core.Roi(Core.Point(256, 512), Core.Size(256, 512))
if acq.checkValidRoi(roi):
acq.setRoi(roi)
roi_tl, roi_size = roi.getTopLeft(), roi.getSize()
deb.Always(
"Run roi=<%s,%s>-<%sx%s>" %
(roi_tl.x, roi_tl.y, roi_size.getWidth(), roi_size.getHeight()))
acq.run()
deb.Always("Done!")
def apply_config(self, c):
try:
active = c.get("active", False)
self.Stop()
if active:
self._runLevel = c.get("runLevel", 0)
self.Start()
namedRois = []
names = []
for name, d in c.iteritems():
try:
if isinstance(d, dict):
rType = d.get("type", None)
if rType == RoiCounterTask.SQUARE:
x = d["x"]
y = d["y"]
width = d["width"]
height = d["height"]
namedRois.append(
(name, Core.Roi(x, y, width, height)))
elif rType == RoiCounterTask.ARC:
x = d["x"]
y = d["y"]
r1 = d["r1"]
r2 = d["r2"]
a1 = d["a1"]
a2 = d["a2"]
namedRois.append(
(name, Core.ArcRoi(x, y, r1, r2, a1, a2)))
elif rType == RoiCounterTask.MASK:
x = d["x"]
y = d["y"]
data = d["data"]
self.__roiCounterMgr.setLutMask(
name, Core.Point(x, y), data)
elif rType == RoiCounterTask.LUT:
x = d["x"]
y = d["y"]
data = d["data"]
self.__roiCounterMgr.setLut(
name, Core.Point(x, y), data)
names.append(name)
except KeyError as err:
PyTango.Except.throw_exception(
'Config error',
'Missing key %s in roi named %s' % (err, name),
'RoiCounterDeviceServer Class')
self.__roiCounterMgr.updateRois(namedRois)
self.add(names)
except:
import traceback
traceback.print_exc()
def setRois(self,argin) :
if self.__roiCounterMgr is None:
raise RuntimeError('should start the device first')
if not len(argin) % 5:
roi_list = []
for roi_id,x,y,width,height in grouper(5,argin):
roi_name = self.__roiID2Name.get(roi_id,None)
if roi_name is None:
raise RuntimeError('should call add method before setRoi')
roi_list.append((roi_name,Core.Roi(x,y,width,height)))
self.__roiCounterMgr.updateRois(roi_list)
else:
raise AttributeError('should be a vector as follow [roi_id0,x0,y0,width0,height0,...')
def setKinPars(self, kin_win_size, kin_line_beg, kin_stripes):
deb.Param('Setting kin pars: ' +
'kin_win_size=%s, kin_line_beg=%s, kin_stripes=%s' % \
(kin_win_size, kin_line_beg, kin_stripes))
if kin_stripes > 1:
deb.Warning('Ignoring kin_stripes=%d' % kin_stripes)
bin = _FrelonAcq.getBin()
if kin_win_size % bin.getY() != 0:
msg = 'Invalid kinetics window size (%d): ' % kin_win_size + \
'must be multiple of vert. bin (%d)' % bin.getY()
raise Core.Exception, msg
roi = _FrelonAcq.getRoi()
roi = roi.getUnbinned(bin)
tl = Core.Point(roi.getTopLeft().x, kin_line_beg)
size = Core.Size(roi.getSize().getWidth(), kin_win_size)
roi = Core.Roi(tl, size)
roi = roi.getBinned(bin)
_FrelonAcq.setRoi(roi)
_FrelonAcq.setRoiLineBegin(kin_line_beg)
cam_ctr = Core.CtControl(cam_int)
print("\n** Removing all files that could interfer with acquisition :")
os.system("rm -fv /mnt/DataHub3/iGEM/20170903/camera/testing*.tiff")
print("\n** Taking care of the saving format : 1st serie is wihtOUT saving")
cam_sav = cam_ctr.saving()
cam_sav.setDirectory("/mnt/DataHub3/iGEM/20170903/camera")
cam_sav.setPrefix("testing")
cam_sav.setSavingMode(Core.CtSaving.Manual)
print(cam_sav.getParameters())
print("** Testing the ROI : 100, 100, 2360, 1960 (in HardOnly mode)")
cam_ctr.image().setMode(Core.CtImage.HardOnly)
cam_ctr.image().setRoi(Core.Roi(100, 100, 2360,
1960)) ### left, top, width, height
the_roi = cam_ctr.image().getRoi()
print("\tThe retrieved roi is (%d, %d, %d, %d)" %
(the_roi.getTopLeft().x, the_roi.getTopLeft().y,
the_roi.getSize().getWidth(), the_roi.getSize().getHeight()))
print("\n**Testing the acquisition exposure and latency :")
## ##### Faster frame-rates, lower latency :
## cam.setElectronicShutterMode(Andor3.Camera.Rolling)
## cam.setAdcRate(cam.MHz280)
## cam.getLatTimeRange() ## 0.0103
## ##### Slower frame-rate, higher latency :
## cam.setElectronicShutterMode(Andor3.Camera.Global)
## cam.setAdcRate(cam.MHz100)
## cam.getLatTimeRange() ## 0.0286
def test_frelon_acc(enable_debug, espia_dev_nb, vert_bin, exp_time,
acc_max_exp_time, nb_frames, acc_time_mode):
if enable_debug:
Core.DebParams.enableModuleFlags(Core.DebParams.AllFlags)
Core.DebParams.enableTypeFlags(Core.DebParams.AllFlags)
else:
Core.DebParams.disableModuleFlags(Core.DebParams.AllFlags)
deb.Always("Creating FrelonAcq")
acq = Frelon.FrelonAcq(espia_dev_nb)
deb.Trace("Done!")
cam = acq.getFrelonCamera()
ct = acq.getGlobalControl()
ct_image = ct.image()
ct_acq = ct.acquisition()
acq_state = Core.AcqState()
status_cb = ImageStatusCallback(ct, acq_state)
ct.registerImageStatusCallback(status_cb)
deb.Always("Setting Full Frame Mode - Speed - Chan 3&4")
cam.setSPB2Config(Frelon.SPB2Speed)
cam.setFrameTransferMode(Frelon.FFM)
cam.setInputChan(Frelon.Chan34)
deb.Trace("Done!")
frame_dim = acq.getFrameDim(max_dim=True)
bin = Core.Bin(1, vert_bin)
deb.Always("Setting binning %s" % bin)
ct_image.setBin(bin)
deb.Trace("Done!")
image_size = frame_dim.getSize()
nb_cols = image_size.getWidth()
nb_lines = image_size.getHeight() / vert_bin
roi = Core.Roi(Core.Point(0, nb_lines - 2), Core.Size(nb_cols, 1))
deb.Always("Setting RoI %s" % roi)
ct_image.setRoi(roi)
deb.Trace("Done!")
deb.Always("Setting Kinetic RoI mode")
cam.setRoiMode(Frelon.Kinetic)
deb.Trace("Done!")
deb.Always("Setting Acc. mode")
ct_acq.setAcqMode(Core.Accumulation)
deb.Trace("Done!")
deb.Always("Setting %s Acc. Time mode" % acc_time_mode)
acc_mode = Core.CtAcquisition.Live \
if acc_time_mode == 'Live' \
else Core.CtAcquisition.Real
ct_acq.setAccTimeMode(acc_mode)
deb.Trace("Done!")
deb.Always("Setting Acc. max. exp. time %s" % acc_max_exp_time)
ct_acq.setAccMaxExpoTime(acc_max_exp_time)
deb.Trace("Done!")
deb.Always("Setting exp. time %s" % exp_time)
ct_acq.setAcqExpoTime(exp_time)
deb.Trace("Done!")
deb.Always("Setting nb. frames %s" % nb_frames)
ct_acq.setAcqNbFrames(nb_frames)
deb.Trace("Done!")
acc_nb_frames = ct_acq.getAccNbFrames()
acc_dead_time = ct_acq.getAccDeadTime()
acc_live_time = ct_acq.getAccLiveTime()
deb.Always("AccNbFrames: %d, AccDeadTime: %.6f, AccLiveTime: %.6f" %
(acc_nb_frames, acc_dead_time, acc_live_time))
deb.Always("Preparing acq.")
ct.prepareAcq()
deb.Trace("Done!")
deb.Always("Starting acq.")
status_cb.start()
ct.startAcq()
deb.Trace("Done!")
state_mask = Core.AcqState.Acquiring
acq_state.waitNot(state_mask)
deb.Always("Finished!")
dead_time = cam.getDeadTime()
read_time = cam.getReadoutTime()
xfer_time = cam.getTransferTime()
deb.Always("Dead Time: %.6f, Readout Time: %.6f, Transfer Time: %.6f" %
(dead_time, read_time, xfer_time))
def main(argv):
deb.Always("Creating Espia.Dev")
edev = Espia.Dev(0)
deb.Always("Creating Espia.Acq")
acq = Espia.Acq(edev)
acqstat = acq.getStatus()
deb.Always("Whether the Acquisition is running : %s" % acqstat.running)
deb.Always("Creating Espia.BufferMgr")
buffer_cb_mgr = Espia.BufferMgr(acq)
deb.Always("Creating BufferCtrlMgr")
buffer_mgr = Core.BufferCtrlMgr(buffer_cb_mgr)
deb.Always("Creating Espia.SerialLine")
eser_line = Espia.SerialLine(edev)
deb.Always("Creating Frelon.Camera")
cam = Frelon.Camera(eser_line)
deb.Always("Creating the Hw Interface ... ")
hw_inter = Frelon.Interface(acq, buffer_mgr, cam)
deb.Always("Creating HW BufferSave")
buffer_save = Core.HwBufferSave(Core.HwBufferSave.EDF, "img", 0, ".edf",
True, 1)
deb.Always("Getting HW detector info")
hw_det_info = hw_inter.getHwCtrlObj(Core.HwCap.DetInfo)
deb.Always("Getting HW buffer")
hw_buffer = hw_inter.getHwCtrlObj(Core.HwCap.Buffer)
deb.Always("Getting HW Sync")
hw_sync = hw_inter.getHwCtrlObj(Core.HwCap.Sync)
deb.Always("Getting HW Bin")
hw_bin = hw_inter.getHwCtrlObj(Core.HwCap.Bin)
deb.Always("Getting HW RoI")
hw_roi = hw_inter.getHwCtrlObj(Core.HwCap.Roi)
mis_cb = MaxImageSizeCallback()
hw_det_info.registerMaxImageSizeCallback(mis_cb)
deb.Always("Setting FTM")
cam.setFrameTransferMode(Frelon.FTM)
deb.Always("Setting FFM")
cam.setFrameTransferMode(Frelon.FFM)
soft_roi = Core.Roi()
acq_state = Core.AcqState()
deb.Always("Creating a TestFrameCallback")
cb = TestFrameCallback(hw_inter, soft_roi, buffer_save, acq_state)
do_reset = False
if do_reset:
deb.Always("Reseting hardware ...")
hw_inter.reset(HwInterface.HardReset)
deb.Always(" Done!")
size = hw_det_info.getMaxImageSize()
image_type = hw_det_info.getCurrImageType()
frame_dim = Core.FrameDim(size, image_type)
bin = Core.Bin(Core.Point(1))
hw_bin.setBin(bin)
#Roi set_roi, real_roi;
#set_hw_roi(hw_roi, set_roi, real_roi, soft_roi);
effect_frame_dim = Core.FrameDim(frame_dim) # was (frame_dim / bin)
hw_buffer.setFrameDim(effect_frame_dim)
hw_buffer.setNbBuffers(10)
hw_buffer.registerFrameCallback(cb)
hw_sync.setExpTime(2)
hw_sync.setNbFrames(3)
deb.Always("Starting Acquisition")
acq_state.set(Core.AcqState.Acquiring)
hw_inter.startAcq()
deb.Always("Waiting acq finished...")
acq_state.waitNot(Core.AcqState.Acquiring)
deb.Always("Acq finished!!")
deb.Always("Stopping Acquisition")
hw_inter.stopAcq()
deb.Always("This is the End...")
import sys,time,os
from Lima import Core,Andor3
cam = Andor3.Camera("/usr/local/andor/bitflow", 0)
cam_int = Andor3.Interface(cam)
cam_ctr = Core.CtControl(cam_int)
## Proper way of doing that is :
cam_ctr.acquisition().setAcqExpoTime(.001)
cam_ctr.acquisition().setLatencyTime(.001)
cam_ctr.image().setMode(Core.CtImage.HardOnly)
##cam_ctr.image().setMode(Core.CtImage.HardAndSoft)
cam_ctr.image().setRoi(Core.Roi(0, 0, 2048, 2048)) ### left, top, width, height
import time
import numpy
import numpy.fft
import matplotlib
matplotlib.use('TkAgg') # do this before importing pylab
import matplotlib.pyplot as plt
def get_image():
cam.setNbFrames(1)
cam_ctr.prepareAcq()
cam_ctr.startAcq()
while cam_ctr.getStatus().AcquisitionStatus: pass
return cam_ctr.ReadImage().buffer
Core.DebParams.setTypeFlags(Core.DebParams.AllFlags)
cam = Simulator.Camera()
frame_dim = Core.FrameDim(Core.Size(800, 600), Core.Bpp32)
cam = Simulator.Camera()
getter = cam.getFrameGetter()
getter.setFrameDim(frame_dim)
hwint = Simulator.Interface(cam)
control = Core.CtControl(hwint)
acq = control.acquisition()
acq.setAcqNbFrames(1)
img = control.image()
roi = Core.Roi(300,50,450,300)
img.setRoi(roi)
# img.setBin(Core.Bin(2, 2))
img.setRotation(Core.Rotation_90)
control.prepareAcq();
control.startAcq();
while control.getStatus() == Core.AcqRunning:
time.sleep(0.001)
control.stopAcq();
frame = control.ReadImage(0)
cam_sav.setSuffix(".nxs")
## TIFF :
cam_sav.setFormat(Core.CtSaving.TIFFFormat)
cam_sav.setSuffix(".tiff")
cam_sav.getParameters()
## Proper way of doing that is :
cam_ctr.acquisition().setAcqExpoTime(.001)
cam_ctr.acquisition().setLatencyTime(.001)
cam_ctr.acquisition().setAcqNbFrames(10)
cam_ctr.image().setMode(Core.CtImage.HardOnly)
##cam_ctr.image().setMode(Core.CtImage.HardAndSoft)
cam_ctr.image().setRoi(Core.Roi(409, 201, 1776, 1760)) ### left, top, width, height
## Core.DebParams.setTypeFlags( Core.DebParams.getTypeFlags() | Core.DebTypeTrace )
Core.DebParams.setTypeFlagsNameList(['Fatal', 'Error', 'Warning', 'Trace', 'Funct'])
cam_ctr.video().startLive()
time.sleep(3)
cam_ctr.video().stopLive()
cam_ctr.prepareAcq()
cam_ctr.startAcq()
time.sleep(1)
cam_ctr.stopAcq()
im1 = cam_ctr.ReadImage()
def test_frelon_control(enable_debug, use_events, print_time, sleep_time,
all_frames):
if enable_debug:
Core.DebParams.enableModuleFlags(Core.DebParams.AllFlags)
Core.DebParams.enableTypeFlags(Core.DebParams.AllFlags)
else:
Core.DebParams.disableModuleFlags(Core.DebParams.AllFlags)
deb.Always("Creating FrelonAcq")
espia_dev_nb = 0
acq = FrelonAcq(espia_dev_nb, use_events, print_time, sleep_time,
all_frames)
deb.Always("Done!")
acq.initSaving("data", "img", ".edf", 0, Core.CtSaving.EDF,
Core.CtSaving.AutoFrame, 1);
deb.Always("First run with default pars")
acq.run()
deb.Always("Done!")
exp_time = 1e-6
acq.setExpTime(exp_time)
nb_acq_frames = 500
acq.setNbAcqFrames(nb_acq_frames)
deb.Always("Run exp_time=%s, nb_acq_frames=%s" % (exp_time, nb_acq_frames))
acq.run()
deb.Always("Done!")
bin = Core.Bin(2, 2)
acq.setBin(bin)
nb_acq_frames = 5
acq.setNbAcqFrames(nb_acq_frames)
deb.Always("Run bin=<%sx%s>, nb_acq_frames=%s" %
(bin.getX(), bin.getY(), nb_acq_frames))
acq.run()
deb.Always("Done!")
roi = Core.Roi(Core.Point(256, 256), Core.Size(512, 512));
acq.setRoi(roi);
roi_tl, roi_size = roi.getTopLeft(), roi.getSize()
deb.Always("Run roi=<%s,%s>-<%sx%s>" %
(roi_tl.x, roi_tl.y,
roi_size.getWidth(), roi_size.getHeight()))
acq.run()
deb.Always("Done!")
roi = Core.Roi(Core.Point(267, 267), Core.Size(501, 501));
acq.setRoi(roi);
roi_tl, roi_size = roi.getTopLeft(), roi.getSize()
deb.Always("Run roi=<%s,%s>-<%sx%s>" %
(roi_tl.x, roi_tl.y,
roi_size.getWidth(), roi_size.getHeight()))
acq.run()
deb.Always("Done!")
getter = cam.getFrameGetter()
getter.setFrameDim(frame_dim)
hwint = Simulator.Interface(cam)
control = Core.CtControl(hwint)
acq = control.acquisition()
acq.setAcqNbFrames(1)
acq.setAcqExpoTime(0.001)
img = control.image()
print("Attach debugger now")
input()
roi = Core.Roi(1, 1, 598, 298) # Almost full frame
#roi = Core.Roi(0, 0, 600, 300) # Full frame
img.setRoi(roi)
rots = [
Core.Rotation_0, Core.Rotation_90, Core.Rotation_180, Core.Rotation_270
]
binnings = [Core.Bin(1, 1), Core.Bin(1, 2), Core.Bin(2, 1), Core.Bin(2, 2)]
flips = [
Core.Flip(False, False),
Core.Flip(False, True),
Core.Flip(True, False),
Core.Flip(True, True)
]
#frame_dim = Core.FrameDim(Core.Size(800, 600), Core.Bpp32)
frame_dim = Core.FrameDim(Core.Size(600, 600), Core.Bpp32)
cam = Simulator.Camera()
getter = cam.getFrameGetter()
getter.setFrameDim(frame_dim)
hwint = Simulator.Interface(cam)
control = Core.CtControl(hwint)
acq = control.acquisition()
acq.setAcqNbFrames(1)
acq.setAcqExpoTime(0.001)
img = control.image()
#roi = Core.Roi(300,50,450,300)
roi = Core.Roi(160, 60, 120, 200)
img.setRoi(roi)
rots = [
Core.Rotation_0, Core.Rotation_90, Core.Rotation_180, Core.Rotation_270
]
binnings = [Core.Bin(1, 1), Core.Bin(1, 2), Core.Bin(2, 1), Core.Bin(2, 2)]
flips = [
Core.Flip(False, False),
Core.Flip(False, True),
Core.Flip(True, False),
Core.Flip(True, True)
]
# Python function to print permutations of a given list (from SO)
