def save_worker(save_queue, data_queue, process_values, trigger, session_count, gui=None): """ The thread worker used save and analyze the pictures from CameraThread. :argument queue: The queue used to store all of the pictures recieved from XimeaController. :type queue: Queue.Queue :argument process_values: All of the ProcessImage settings in ScarberrySettings. :type process_values: dict :argument trigger: The ThreadTrigger which contains all of the booleans for thread syncing. :type trigger: ThreadTrigger :argument session_count: The number of the current instance of the threads :type session_count: int :keyword gui: Optional interface used to print. :type gui: Interface.ScarberryGui """ global abort pic_count = 0 while trigger.get(name='runProcess') and not abort: while not save_queue.empty() and not abort: pic = save_queue.get() Interface.choose_print(gui, 'save', 'pic {} hex: {}'.format(pic_count,pic)) formated_number = ProcessImage.format_number(pic_count,int(process_values.get("NumberPadding"))) save_name = process_values.get("BaseName") if process_values.get("Count") > 0: save_name = '{}.{}'.format(save_name,session_count) ProcessImage.save_image(pic, formated_number, image_direcoty=process_values.get("ImageDirectory"), name=save_name, extention=process_values.get("FileExtension")) data_queue.put(pic) pic_count += 1 trigger.set_off('runData') Interface.choose_print(gui, 'save', 'SaveImageThread: Finished')
def arduino_worker(arduino_values,main_values,trigger,gui=None): """ The thread worker used to start, format, and end communication with the Arduino integral for the operation of ProjectScarberry. :argument arduino_values: All of the Arduino settings in ScarberrySettings. :type arduino_values: dict :argument main_values: All of the Main settings in ScarberrySettings. :type main_values: dict :argument trigger: The ThreadTrigger which contains all of the booleans for thread syncing. :type trigger: ThreadTrigger :keyword gui: Optional interface used to print. :type gui: Interface.ScarberryGui """ global abort wait = True controller = ArduinoController.ArduinoController(arduino_values.get("SerialPort"),gui=gui) if not abort: controller.write_value(arduino_values.get("FrameRate")) controller.write_value(arduino_values.get("StrobeCount")) controller.write_value(arduino_values.get("DutyCycle")) while not trigger.get(name='startArduino') and wait: if abort: wait = False if not abort: controller.write_value(1) trigger.set_on('startCamera') time.sleep(float(main_values.get("RunTime"))+1) controller.write_value(4) trigger.set_off('startCamera') Interface.choose_print(gui, 'arduino', 'ArduinoThread: Finished')
def camera_worker(queue,camera_values,arduino_values,trigger,gui=None): """ The thread worker used to start, format, and end communication with the Ximea camera integral for the operation of ProjectScarberry. :argument queue: The queue used to store all of the pictures recieved from XimeaController. :type queue: Queue.Queue :argument camera_values: All of the XimeaController settings in ScarberrySettings. :type camera_values: dict :argument arduino_values: All of the Arduino settings in ScarberrySettings. :type arduino_values: dict :argument trigger: The ThreadTrigger which contains all of the booleans for thread syncing. :type trigger: ThreadTrigger :keyword gui: Optional interface used to print. :type gui: Interface.ScarberryGui """ global abort camera = XimeaController.XimeaCamera(arduino_values.get("FrameRate"), gain=camera_values.get("Gain"), gui=gui) wait = True trigger.set_on('startArduino') while not trigger.get(name='startCamera') and wait: if abort: wait = False if not abort: camera.start_acquisition() while trigger.get(name='startCamera') and not abort: current_image = camera.get_image() queue.put(current_image) camera.stop_acquisition() trigger.set_off('runProcess') Interface.choose_print(gui, 'camera', 'CameraThread: Finished')
def get_image(self): """ Prompts the Ximea camera to capture a photo after the next GPI spike. """ try: self.camera.get_image(self.image) return self.image.get_image_data_numpy() except xiapi.Xi_error: Interface.choose_print(self.gui, 'camera', 'Xi_error: ERROR 10: Timeout') Main.abort_session() return None
def data_worker(queue, process_values, trigger, session_count, gui=None): """ The thread worker used save and analyze the pictures from CameraThread. :argument queue: The queue used to store all of the pictures recieved from XimeaController. :type queue: Queue.Queue :argument process_values: All of the ProcessImage settings in ScarberrySettings. :type process_values: dict :argument trigger: The ThreadTrigger which contains all of the booleans for thread syncing. :type trigger: ThreadTrigger :argument session_count: The number of the current instance of the threads :type session_count: int :keyword gui: Optional interface used to print. :type gui: Interface.ScarberryGui """ global abort pic_count = 0 data_directory = process_values.get("ImageDirectory") + '\\data' if not os.path.exists(data_directory): os.makedirs(data_directory) while trigger.get(name='runData') and not abort: while not queue.empty() and not abort: pic = queue.get() Interface.choose_print(gui, 'data', 'pic {} hex: {}'.format(pic_count, pic)) formated_number = ProcessImage.format_number(pic_count, int(process_values.get("NumberPadding"))) save_name = process_values.get("BaseName") if process_values.get("Count") > 0: save_name = '{}.{}'.format(save_name, session_count) data_filename = '{}\\data-{}_{}{}'.format(data_directory, save_name, formated_number, '.txt') if process_values.get("SaveDraw"): ProcessImage.draw_and_data(pic, '{}\\data\\data-{}_{}{}'.format(process_values.get("ImageDirectory"), save_name, formated_number, process_values.get("FileExtension")), data_filename, process_values.get("BlurValue"), process_values.get("ThreshLimit"), draw_rois=process_values.get("DrawROIs"), draw_centroid=process_values.get("DrawCentroid"), draw_colours=process_values.get("DrawColour"), draw_count=process_values.get("DrawCount")) else: data = ProcessImage.get_data(pic, process_values.get("BlurValue"), process_values.get("ThreshLimit")) ProcessImage.save_data(data, data_filename) pic_count += 1 Interface.choose_print(gui, 'data', 'DataImageThread: Finished')
def __init__(self,framerate,gain=0,gui=None): """ Initializes an instance of XimeaCamera. :argument framerate: Number of pictures taken a second. :type framerate: int :keyword gain: Brightness modifier of pictures taken. type gain: int, float [0 to 6](default 0) :keyword gui: Optional interface used to print(default None). :type gui: Interface.ScarberryGui """ self.gui = gui self.image = xiapi.Image() self.camera = xiapi.Camera() Interface.choose_print(gui, 'camera', 'Opening camera...') try: self.camera.open_device() exposure = (1000000 / (int(framerate))) exposure -= math.pow(10, math.floor(math.log(exposure, 10)) - 1) self.camera.set_exposure(int(exposure)) if gain < 0: gain = 0 if gain > 6: gain = 6 self.camera.set_gain(float(gain)) self.camera.set_trigger_source('XI_TRG_EDGE_RISING') self.camera.set_gpi_mode('XI_GPI_TRIGGER') self.camera.set_gpo_selector('XI_GPO_PORT1') self.camera.set_gpo_mode('XI_GPO_FRAME_TRIGGER_WAIT') self.camera.set_imgdataformat('XI_MONO8') except xiapi.Xi_error: Interface.choose_print(gui, 'camera', 'Xi_error: ERROR 56: No Devices Found') Main.abort_session()
def write_value(self,value): """ Write a value to the Arduino over Serial. :argument value: Value to be written to Arduino :type value: string, int, float :argument pause: Amount of time spent paused in seconds :type pause: int, float """ Interface.choose_print(self.gui, 'arduino', 'Writing "{}"...'.format(value)) try: self.serial.write('{}'.format(value)) self.serial.readline() Interface.choose_print(self.gui, 'arduino', 'Wrote: {}'.format(value)) except serial.SerialException: Interface.choose_print(self.gui, 'arduino', 'SerialException: WriteFile failed') Main.abort_session()
def __init__(self,com_number,gui=None): """ Initializes an instance of ArduinoController. :argument com_number: Port number of the Arduino. :type com_number: int :keyword gui: Optional interface used to print(default None). :type gui: Interface.ScarberryGui """ self.gui = gui try: self.serial = serial.Serial('COM{}'.format(com_number),115200) Interface.choose_print(gui, 'arduino', 'Waiting for COM{}...'.format(com_number)) print('Waiting for COM{}...'.format(com_number)) time.sleep(ArduinoController.INITIAL_SLEEP); Interface.choose_print(gui, 'arduino', 'Connected to COM{}.'.format(com_number)) print('Connected to COM{}.'.format(com_number)) except serial.SerialException: Interface.choose_print(self.gui, 'arduino', 'SerialException: could not open COM{}'.format(com_number)) Main.abort_session()
def close_camera(self): """ Closes all communication with the Ximea camera. """ Interface.choose_print(self.gui, 'camera','Closing camera...') self.camera.close_device()
def stop_acquisition(self): """ Stops aquisition of the Ximea camera. """ Interface.choose_print(self.gui, 'camera','Stopping acquisition...') self.camera.stop_acquisition()
def start_acquisition(self): """ Starts acquisition of the Ximea camera. """ Interface.choose_print(self.gui,'camera','Starting data acquisition...') self.camera.start_acquisition()