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()
