def findallcams(self): """Find all cameras of this vendor Returns ------- cams : dictionary Dictionary of all connected cameras where the key is the unique id that can be used to obtain a camera handle. The value is a description of the camera presented to the user. """ res = {} cams = [xiapi.Camera(0)] ndev = cams[0].get_number_devices() log.info('Found %i ximea cameras' % ndev) if ndev == 0: log.error('No cameras found') for ii in range(ndev - 1): cams.append(xiapi.Camera(ii + 1)) for ii in range(ndev): serial = cams[ii].get_device_info_string("device_sn").decode( "utf8") res[serial] = { "serial": serial, "type": cams[ii].get_device_info_string("device_type").decode("utf8"), "name": cams[ii].get_device_info_string("device_name").decode("utf8"), } return res
def _cam_init(self, set_gpio=True): self.cam = xiapi.Camera() #start communication self.cam.open_device() self.cam.set_acq_timing_mode('XI_ACQ_TIMING_MODE_FREE_RUN') self.cam.set_exposure(self.exposure) self.cam.set_binning_vertical(self.binning) self.cam.set_binning_horizontal(self.binning) # Set the GPIO self.cam.set_gpi_selector('XI_GPI_PORT1') self.cam.set_trigger_source('XI_TRG_OFF') if set_gpio: self.cam.set_gpo_selector('XI_GPO_PORT1') # for now set the GPO to blink in software (port1 will do that for sync purposes, the test cam does not support XI_GPO_EXPOSURE_PULSE) self.cam.set_gpo_mode('XI_GPO_ON') #XI_GPO_EXPOSURE_PULSE if self.triggered.is_set(): self.cam.set_gpi_mode('XI_GPI_TRIGGER') self.cam.set_trigger_source('XI_TRG_EDGE_RISING') self.cam.set_led_selector('XI_LED_SEL1') self.cam.set_led_mode('XI_LED_OFF') self.cam.set_led_selector('XI_LED_SEL2') self.cam.set_led_mode('XI_LED_OFF') self.cam.set_led_selector('XI_LED_SEL3') self.cam.set_led_mode('XI_LED_OFF') self.cambuf = xiapi.Image() self.lastframeid = -1 self.nframes.value = 0 self.camera_ready.set()
def init_camera(cam_id, settings_file, logger): ''' Initialize a ximea camera for use (recoring and preview) by external scripts Params: cam_id (str): Serial number of camera to opening setttings_file (str): Path to settings file for camera logger (instace of class logger): used to pass messages to gui Returns: camera (instace of class Ximea Camera): A camera that produces Images iamge_handle (Ximea Camera image): handle to point to images from camera open_success (bool): Were we able to open the camera? ''' try: logger.info(f'Opening Ximea Camera {cam_id}') camera = xiapi.Camera() camera.open_device_by_SN(cam_id) logger.info('Sucessfully Opened Camera') apply_cam_settings(camera, settings_file) logger.info('Sucessfully Applied Settings to Camera') camera.start_acquisition() image = xiapi.Image() logger.info('Sucessfully Started Aquisition') return (camera, image, True) except: logger.info('Problem initializing camera.') camera.stop_acquisition() camera.close_device() return (None, None, False)
def __init__(self, serial_number: typing.Optional[str] = None, **kwargs) -> None: super().__init__(**kwargs) self._acquiring = False self._handle = xiapi.Camera() self._img = xiapi.Image() self._serial_number = serial_number self._sensor_shape = (0, 0) self._roi = microscope.ROI(None, None, None, None) self._binning = microscope.Binning(1, 1) # When using the Settings system, enums are not really enums # and even when using lists we get indices sent back and forth # (works fine only when using EnumInt. The gymnastic here # makes it work with the rest of enums which are there to make # it work with TriggerTargetMixin. trg_source_names = [x.name for x in TrgSourceMap] def _trigger_source_setter(index: int) -> None: trigger_mode = TrgSourceMap[trg_source_names[index]].value self.set_trigger(trigger_mode, self.trigger_mode) self.add_setting( "trigger source", "enum", lambda: TrgSourceMap(self.trigger_type).name, _trigger_source_setter, trg_source_names, ) self.initialize()
def camInitialize(self): self.cam = xiapi.Camera() self.appendToStatus('Opening Camera with SN: {}...'.format(SN)) self.cam.open_device_by_SN(SN) self.appendToStatus('Camera Model {0} Opened!'.format( self.cam.get_param('device_name'))) global SENSORWIDTH global SENSORHEIGHT SENSORWIDTH = self.cam.get_param('width:max') SENSORHEIGHT = self.cam.get_param('height:max') self.parameters.frameEdit.setText('{:.2f}'.format( 1000.0 / self.cam.get_param('framerate'))) self.appendToStatus('Sensor {0} x {1} pixels.'.format( SENSORWIDTH, SENSORHEIGHT)) ### SET TRIGGER PROPERTIES self.cam.set_param('gpi_mode', 'XI_GPI_TRIGGER') self.cam.set_param('trigger_source', 'XI_TRG_EDGE_RISING') self.cam.set_param('trigger_selector', 'XI_TRG_SEL_FRAME_START') # self.cam.set_param('sensor_bit_depth', 'XI_BPP_10') self.cam.set_param('gain', 5) self.cam.set_param('imgdataformat', 'XI_MONO16') # self.cam.set_param('image_data_bit_depth','XI_BPP_10') print(self.cam.get_param('output_bit_depth')) print(self.cam.get_param('sensor_bit_depth'))
def __init__(self): # create instance for first connected camera self.cam = xiapi.Camera() # start communication print('Opening first camera...') self.cam.open_device() # cam.set_height(100) # cam.set_width(100) # self.cam.set_limit_bandwidth(49 * 8) # settings self.cam.set_exposure(1000) self.cam.set_imgdataformat('XI_MONO8') self.cam.set_acq_timing_mode('XI_ACQ_TIMING_MODE_FRAME_RATE_LIMIT') self.cam.set_downsampling("XI_DWN_2x2") self.cam.set_downsampling_type("XI_SKIPPING") self.cam.set_framerate(100) # cam.get_binning_horizontal_mode() # create instance of Image to store image data and metadata self.img = xiapi.Image() # start data acquisition print('Starting data acquisition...') self.cam.start_acquisition() tic = time.time() self.frame_idx = 0 self.last_frame = None self.prev_frame = None self.stopped = False self.read_lock = threading.Lock() self.start()
def _open_cameras(config): cams = [] for i in range(config['CameraSettings']['num_cams']): print(('loading camera %s ...' % (i))) cams.append(xiapi.Camera(dev_id=i)) cams[i].open_device() return cams
def __init__(self, timeout=500): self.camera = xiapi.Camera() self.camera.open_device() self.camera.set_exposure(10000) self.camera.set_imgdataformat('XI_RAW16') self.camera.start_acquisition() self.img = xiapi.Image()
def __init__(self, exposure=1e6): self.cam = xiapi.Camera() self.cam.open_device() self.cam.set_exposure(exposure) self.cam.set_imgdataformat('XI_RAW16') self.cam.start_acquisition() self._img = xiapi.Image() self._cache = []
def __init__(self, imageformat="raw"): # Opening quantum efficiency data of xiMU MT9P031 fn = os.path.join(os.path.dirname(__file__), "MT9P031_RSR/MT9P031.csv") self.df_sr = pandas.read_csv(fn, sep=";") # Dictionaries for image format and on-chip binning # On-chip binning # 1x1 binning = 4.6 fps = 0.217 s (217 ms) between each image # 2x2 binning = 14.3 fps = 0.0699 s (69.9 ms) between each image # 4x4 binning = 31.6 fps = 0.0316 s (31.6 ms) between each image self.frmt_dict = { "raw": "XI_RAW16", "mono": "XI_MONO16", "color24bits": "XI_RGB24", "color32bits": "XI_RGB32" } self.dwsam_dict = { "1x1": "XI_DWN_1x1", "2x2": "XI_DWN_2x2", "4x4": "XI_DWN_4x4" } # Create ximea Camera instance self.cam = xiapi.Camera() # Create ximea Image instance to store image data and metadata self.img = xiapi.Image() # Opening camera print("Opening device") self.cam.open_device_by("XI_OPEN_BY_SN", "16990159") # Principal parameters that can be controlled self.imformat = self.frmt_dict[imageformat] self.dwsam = "XI_DWN_1x1" self.exp = 10000 self.gain = 0 self.update_cam_param( ) # Updating camera parameters (only time image format is set) # Figure visualization #self.fig = plt.figure(figsize=(11, 7)) self.fig = plt.figure() if self.imformat == "XI_RAW16": self.ax = [] self.text = [] for i in range(6): a = self.fig.add_subplot(3, 2, i + 1) self.ax.append(a) for i in range(1, 7, 2): a = self.ax[i] self.text.append(a.text(1.2, 0.5, "", transform=a.transAxes)) else: self.ax = self.fig.add_subplot(1, 1, 1)
def __init__(self, timeout=500): self.camera = xiapi.Camera() self.camera.open_device() try: self.set_exposure(ccfg.camera_exposure_us) except AttributeError as ae: print ae print "ciao_config.py is missing an entry for exposure time; please put 'camera_exposure_us = 1000' or similar into the ciao_config.py file for your session" sys.exit() self.camera.start_acquisition() self.img = xiapi.Image() self.image = None
def __init__(self): self.cam = xiapi.Camera() self.cam.open_device() self.cam.enable_auto_wb() self.cam.set_exposure(50000) self.cam.set_imgdataformat("XI_RGB24") self.img = xiapi.Image() print('Starting data acquisition...') self.cam.start_acquisition()
def run(self): # cap = cv2.VideoCapture(0) # create instance for first connected camera cam = xiapi.Camera() # start communication print('Opening first camera...') cam.open_device() # settings cam.set_exposure(200000) cam.set_gain(7) is_data_collecting = False while self._run_flag: img = xiapi.Image() if not is_data_collecting: is_data_collecting = True cam.start_acquisition() cam.get_image(img) data = img.get_image_data_numpy() # ret, cv_img = cap.read() if data is not None: print("Data: ") print(data) # cv2.cvtColor(data, cv2.COLOR_RGB2GRAY) data = cv2.cvtColor(data, cv2.COLOR_GRAY2BGR) data = circle_detect(data) self.change_pixmap_signal.emit(data) # else: # TODO This code is only for looping the sample video. # cap.set(cv2.CAP_PROP_POS_FRAMES, 0) # cap.release() # stop data acquisition print('Stopping acquisition...') cam.stop_acquisition() # stop communication cam.close_device()
def camera_init(s_n, framerate, shutter, gain): cam = xiapi.Camera() img = xiapi.Image() cam.open_device_by_SN(s_n) cam.set_sensor_feature_value(1) cam.set_imgdataformat("XI_RAW8") cam.disable_auto_bandwidth_calculation() cam.set_counter_selector("XI_CNT_SEL_API_SKIPPED_FRAMES") cam.set_acq_timing_mode("XI_ACQ_TIMING_MODE_FRAME_RATE") cam.set_framerate(framerate) cam.set_exposure(shutter) cam.set_gain(gain) return cam, img
def __init__(self, **kwargs): """ Parameters ---------- downsampling : int downsampling factor for the camera """ super().__init__(**kwargs) # Test if API for the camera is available try: self.cam = xiapi.Camera() except NameError: raise Exception( "The xiapi package must be installed to use a Ximea camera!")
def __init__(self, roi=(0.18, 0.02, 0.75, 0.85) #[x1, y1, x2, y2] ): import sys sys.path.insert(0, "/home/ICT2000/rli/package/api/Python/v3") from ximea import xiapi from ctypes import c_uint, c_float, c_void_p, c_double self.bbox = np.ceil(np.array(roi) * 2048) print (self.bbox) #create instance for first connected camera cam = xiapi.Camera() #start communication #to open specific device, use: #cam.open_device_by_SN('41305651') #(open by serial number) print('Opening first camera...') cam.open_device() cam.enable_auto_wb() #settings cam.set_exposure(100000) cam.set_imgdataformat("XI_RGB24") print('Exposure was set to %i us' %cam.get_exposure()) print (cam.get_downsampling_type()) cam.set_width(512) cam.set_height(512) cam.set_offsetX(256) cam.set_offsetY(32) # cam.set_downsampling("XI_DWN_4x4") #create instance of Image to store image data and metadata img = xiapi.Image() #start data acquisition print('Starting data acquisition...') cam.start_acquisition() self.cam = cam self.img = img
def __init__(self, dims, exposure): # Configure camera. Default exposure value of 50k cam = xiapi.Camera(dev_id=0) cam.open_device() cam.set_exposure(exposure) cam.set_imgdataformat('XI_RGB24') cam.start_acquisition() # Calibration data self.targetDimensions = dims self.calibrationObjects = [] self.calibrationParams = {} self.undistorted = [] self.cam = cam self.img = xiapi.Image() self.rectifyMask = None
def __init__(self): #create instance for first connected camera self.cam = xiapi.Camera() #start communication print('[xiCamera]\t Opening first camera...') self.cam.open_device() #settings self.cam.set_imgdataformat('XI_RGB32') self.cam.set_exposure(10000) #create instance of Image to store image data and metadata self.img = xiapi.Image() self.open() print('[xiCamera]\t camera successfully started')
def Photo(e, usb, token, exp): try: cam = xiapi.Camera() #start communication cam.open_device() img = xiapi.Image() #setting exposure if (exp == "auto"): cam.enable_aeag() else: cam.set_exposure(int(exp)) #start data acquisition print('Starting data acquisition...\n') cam.start_acquisition() cam.set_imgdataformat('XI_RGB24') while e.is_set(): if (synchronizer.Synchro(token) == 1): try: cam.get_image(img) data_num = img.get_image_data_numpy(invert_rgb_order=True) filename = 'USB_%d' % (int(time.time())) Save.Save(filename, data_num) print("New usb image...") usb["timestamp"] = str(time.gmtime().tm_year) + "-" + str( time.gmtime().tm_mon) + "-" + str( time.gmtime().tm_mday) + "T" + str( time.gmtime().tm_hour) + ":" + str( time.gmtime().tm_min) + ":" + str( time.gmtime().tm_sec) synchronizer.Update() usb["acquiredImages"] = usb["acquiredImages"] + 1 print("token: " + str(token)) except Exception as exc: usb["error"] = str(exc) synchronizer.Update() #stop data acquisition print('Usb Cam: Stopping acquisition...') cam.stop_acquisition() except Exception as err: usb["error"] = str(err) usb["status"] = "error" synchronizer.removefromQueue(token) e.clear() cam.close_device()
def __init__(self, num_cams, camSetDict, init_time): self.cameraList = [] self.init_time = init_time for i in range(num_cams): camera = xiapi.Camera(dev_id=i) #start communication print('Opening camera %s ...' % (i)) camera.open_device() camera.set_imgdataformat(camSetDict['imgdf']) camera.set_exposure(camSetDict['exp_per']) camera.set_gain(camSetDict['gain_val']) camera.set_sensor_feature_value(camSetDict['sensor_feat']) camera.set_gpi_selector(camSetDict['gpi_selector']) camera.set_gpi_mode(camSetDict['gpi_mode']) camera.set_trigger_source(camSetDict['trigger_source']) camera.set_gpo_selector(camSetDict['gpo_selector']) camera.set_gpo_mode(camSetDict['gpo_mode']) self.cameraList.append(camera) self.printCamSet()
def cameraone(): global img global cam global bridge bridge = CvBridge() increment_val = 0 #create instance for first connected camera cam = xiapi.Camera(dev_id=0) #start communication to open specific device, use: #(open by serial number) print('Opening camera...') #cam.set_debug_level("XI_DL_TRACE") cam.open_device() #settings cam.set_downsampling_type('XI_SKIPPING') cam.set_downsampling("XI_DWN_2x2") cam.set_exposure(int(20000)) cam.set_gain(float(5)) #cam.set_acq_timing_mode("XI_ACQ_TIMING_MODE_FREE_RUN") cam.set_limit_bandwidth(2500) #cam.set_buffers_queue_size(10) print('Camera exposure was set to %i us' % cam.get_exposure()) cam.set_imgdataformat('XI_RGB24') #create instance of Image to store image data and metadata img = xiapi.Image() #start data acquisition print('Starting data acquisition...') cam.start_acquisition() rospy.init_node('cameraone', anonymous=True) rate = rospy.Rate(100) try: while not rospy.is_shutdown(): cam.get_image(img, timeout=20000) data_raw = img.get_image_data_numpy() cam_data = bridge.cv2_to_imgmsg(data_raw, "bgr8") pub = rospy.Publisher("image_topic", Image, queue_size=1) pub.publish(cam_data) rate.sleep() except xiapi.Xi_error as err: if err.status == 10: print('Timeout error occured.') else: raise
def __init__(self, config, dev_id=0): self.config = config try: self.cam = xiapi.Camera(dev_id=dev_id) self.cam.open_device() self.cam.set_imgdataformat(self.config.CAMERA_PARAMS['img_format']) self.cam.set_exposure(self.config.CAMERA_PARAMS['exposure']) self.cam.set_param("gain", self.config.CAMERA_PARAMS['gain']) self.cam.set_param("auto_wb", self.config.CAMERA_PARAMS['auto_wb']) self.cam.set_param("framerate", self.config.CAMERA_PARAMS['framerate']) self.status = 0 except Exception as e: print( f"XI_PROCESSOR: Unable to launch camera! Error is: {e}. Aborting" ) exit(-1) print("XI_PROCESSOR: Camera configuration finished successfully!\n") self.img = xiapi.Image()
def __init__(self, serial_number=None, pixelFormat=None): """Constructor method """ # pour le moment on ouvre simplement la première caméra self.cam = xiapi.Camera() if serial_number is None: self.cam.open_device() else: self.cam.open_device_by_SN(serial_number) if pixelFormat is None: if self.cam.is_iscolor(): pixelFormat = "XI_RGB24" else: pixelFormat = "XI_MONO8" elif pixelFormat not in XI_IMG_FORMAT: raise ValueError( f"Wrong pixelFormat. Possible values are {set(XI_IMG_FORMAT.keys()):}" ) self.cam.set_imgdataformat(pixelFormat) print(f"Camera {self.name:} opened ({pixelFormat:})")
def _initialize_Camera_Ximea(self): self.cameraObject = xi.Camera() self.cameraObject.open_device() if self.imageParams is None: #if no value is provided use the full feild of view x2 = self.cameraObject.get_width_maximum() y2 = self.cameraObject.get_height_maximum() self.imageParams = [0, x2, 0, y2] self._catch_And_Fix_Errors() self.cameraObject.set_imgdataformat( 'XI_MONO16' ) #return data with the greatest depth possible. Otherwise data #is forced to fit into an 8 bit array self.cameraObject.set_exposure( int(self.expTime * 1E3)) #exposure time is in microseconds for ximea camera #Turn off every feature that I can. Who knows whats happening if these are on? I'm not even confident in this #camera with these off self.cameraObject.set_gain(0) self.cameraObject.disable_bpc() self.cameraObject.disable_ffc() self.cameraObject.disable_aeag() self.cameraObject.disable_LUTEnable() #----disable obnoxious image clamping thing---- self.cameraObject.set_param('device_unit_register_selector', 0x0222) self.cameraObject.set_param('device_unit_register_value', 0xF0) x1, x2, y1, y2 = self.imageParams xWidth = x2 - x1 yWidth = y2 - y1 yMax = self.cameraObject.get_height_maximum() self.cameraObject.set_width(xWidth) self.cameraObject.set_height(yWidth) self.cameraObject.set_offsetX(x1) self.cameraObject.set_offsetY( yMax - yWidth - y1) #image coordinates are top left, but I want from bottom left self.cameraObject.start_acquisition()
def cam_setup(expo=10): ''' This function receives exposure time in milisec and sets up the camera ready for live feed ''' #create instance for the connected camera cam = xiapi.Camera() #start communication print('\nOpening the camera...') cam.open_device() #settings cam.set_imgdataformat('XI_RGB24') cam.set_exposure(expo * 1000) print('\nExposure was set to %i us' %cam.get_exposure()) #start data acquisition print('\nStarting data acquisition...') cam.start_acquisition() return cam
def __init__(self, serialnumber="", xbinwidth=896, xbinoffset=528): self.xicam = xiapi.Camera() if len(serialnumber) == 0: self.xicam.open_device() else: self.xicam.open_device_by_SN(serialnumber) log.info("Conected to device, %s!", self.xicam.get_device_sn()) self.exposure = 5 self.gain = 0 self.xicam.set_imgdataformat("XI_RAW16") self.xicam.set_output_bit_depth("XI_BPP_12") self.xicam.enable_output_bit_packing() self.xicam.disable_aeag() self.xicam.set_binning_vertical(2) self.xicam.set_binning_vertical_mode("XI_BIN_MODE_SUM") self.xbinwidth = 896 self.xbinoffset = 528 self.img = xiapi.Image()
def __init__(self, serialnumber: str = None, xbinwidth: int = 896, xbinoffset: int = 528, exposure_ms: int = 1000, gain: int = 0): """Init the camera""" self.xicam = xiapi.Camera() self.xicam.open_device_by_SN( serialnumber) if serialnumber else self.xicam.open_device() print(f'Connected to device {self.xicam.get_device_sn()}') self.xbinwidth = xbinwidth self.xbinoffset = xbinoffset self.exposure = exposure_ms # ms? self.gain = 0 self.xicam.set_width(self.xbinwidth) self.xicam.set_offsetX(self.xbinoffset) self.xicam.set_exposure_direct(1000 * self.exposure) self.xicam.set_gain_direct(self.gain) # What other settings are there?, can we make these *args, **kwargs? and check # them using getattr() self.xicam.set_imgdataformat("XI_RAW16") self.xicam.set_output_bit_depth("XI_BPP_12") self.xicam.enable_output_bit_packing() self.xicam.disable_aeag() # what is this? self.xicam.set_binning_vertical(2) self.xicam.set_binning_vertical_mode("XI_BIN_MODE_SUM") self.rows, self.cols = self.xicam.get_height(), self.xicam.get_width() self.img = xiapi.Image() self.xicam.start_acquisition()
def get_WB_coef(s_n, framerate, shutter, gain): cam = xiapi.Camera() img = xiapi.Image() cam.open_device_by_SN(s_n) cam.set_sensor_feature_value(1) cam.set_imgdataformat("XI_RGB24") cam.set_acq_timing_mode("XI_ACQ_TIMING_MODE_FRAME_RATE") cam.set_framerate(framerate) cam.set_exposure(shutter) cam.set_gain(gain) cam.enable_auto_wb() cam.start_acquisition() start = time.monotonic() while (time.monotonic() - start) <= 1: cam.get_image(img) kR = cam.get_wb_kr() kG = cam.get_wb_kg() kB = cam.get_wb_kb() cam.stop_acquisition() cam.close_device() return kR, kG, kB
from ximea import xiapi import cv2 cam1 = xiapi.Camera() cam1.open_device_by_SN("39050251") framerate = 120.0 shutter = int((1 / framerate) * 1e+6) - 100 gain = 15 # cam1.set_sensor_feature_value(1) cam1.set_exposure(shutter) cam1.set_gain(gain) cam1.set_acq_timing_mode("XI_ACQ_TIMING_MODE_FRAME_RATE") cam1.set_framerate(framerate) # cam1.set_imgdataformat("XI_RGB32") cam1.set_imgdataformat("XI_MONO8") cam1.enable_auto_wb() img1 = xiapi.Image() cam1.start_acquisition() font = cv2.FONT_HERSHEY_COMPLEX_SMALL try: while True: cam1.get_image(img1) data = img1.get_image_data_numpy() # print(cam1.get_framerate()) cv2.putText(data, "cam1: ca 30 deg", (20, 20), font, 1, (0, 0, 0), 1)
import time import sys, signal, os import numpy as np from matplotlib import pyplot as plt #import skvideo #skvideo.setFFmpegPath(r'D:\Fernandes\ffmpeg-20200724-21442a8-win64-static\bin') #import skvideo.io '''default recording parameters''' width = 320 height = 256 fps = 100 #create instance for first connected camera cam = xiapi.Camera() #start communication print('Opening camera...') cam.open_device() #settings cam.set_imgdataformat('XI_MONO8') cam.set_acq_timing_mode("XI_ACQ_TIMING_MODE_FRAME_RATE") #create instance of Image to store image data and metadata img = xiapi.Image()