def captureSetup(self, x_start, x_end, x_bin, y_start, y_end, y_bin, exposure_time):
"""
Configure for image capture (circular buffer).
The camera is zero indexed.
exposure_time is in milliseconds by default?
How to determine the number of frames per second at a given exposure
time? HAL will need to know this in order to time other things properly.
"""
self.frame_x = int((x_end - x_start + 1)/x_bin)
self.frame_y = int((y_end - y_start + 1)/y_bin)
# Setup acquisition & determine how large a frame is (in pixels).
frame_size = pvc.uns32(0)
region = pvc.rgn_type(x_start, x_end, x_bin, y_start, y_end, y_bin)
check(pvcam.pl_exp_setup_cont(self.hcam,
pvc.uns16(1),
ctypes.byref(region),
pvc.int16(pvc.TIMED_MODE),
pvc.uns32(exposure_time),
ctypes.byref(frame_size),
pvc.int16(pvc.CIRC_OVERWRITE)),
"pl_exp_setup_cont")
# Store frame size in bytes.
#
self.frame_bytes = frame_size.value
# Allocate storage for the frames. Use PVCAM's recommendation for the size.
#
size = self.getParameterDefault("param_frame_buffer_size")
self.data_buffer = numpy.ascontiguousarray(numpy.zeros(size, dtype = numpy.uint8))
self.buffer_len = int(size/self.frame_bytes)
def getParameterEnum(self, pname, pindex = None):
"""
Returns value and description for an enumerated type.
"""
pid = self.nameToID(pname)
ptype = self.getParameterType(pid)
pvalue = pvc.int32()
# Verify that this is an enumerated type.
if (ptype != pvc.TYPE_ENUM):
raise PVCAMException("getParameterEnum: " + str(ptype) + " is not an enumerated type.")
# Use current index if not specified.
if pindex is None:
cindex = pvc.uns32(pvc.ATTR_CURRENT)
else:
cindex = pvc.uns32(pindex)
# Create string to store results.
maxlen = 100
cstring = ctypes.c_char_p((' ' * maxlen).encode())
check(pvcam.pl_get_enum_param(self.hcam,
pid,
cindex,
ctypes.byref(pvalue),
cstring,
pvc.uns32(maxlen)),
"pl_get_enum_param")
return [pvalue.value, cstring.value.decode()]
def getParameterEnum(self, pname, pindex = None):
"""
Returns value and description for an enumerated type.
"""
pid = self.nameToID(pname)
ptype = self.getParameterType(pid)
pvalue = pvc.int32()
# Verify that this is an enumerated type.
if (ptype != pvc.TYPE_ENUM):
raise PVCAMException("getParameterEnum: " + str(ptype) + " is not an enumerated type.")
# Use current index if not specified.
if pindex is None:
cindex = pvc.uns32(pvc.ATTR_CURRENT)
else:
cindex = pvc.uns32(pindex)
# Create string to store results.
maxlen = 100
cstring = ctypes.c_char_p((' ' * maxlen).encode())
check(pvcam.pl_get_enum_param(self.hcam,
pid,
cindex,
ctypes.byref(pvalue),
cstring,
pvc.uns32(maxlen)),
"pl_get_enum_param")
return [pvalue.value, cstring.value.decode()]
def captureSetup(self, x_start, x_end, x_bin, y_start, y_end, y_bin, exposure_time):
"""
Configure for image capture (circular buffer).
The camera is zero indexed.
exposure_time is in milliseconds by default?
How to determine the number of frames per second at a given exposure
time? HAL will need to know this in order to time other things properly.
"""
self.frame_x = int((x_end - x_start + 1)/x_bin)
self.frame_y = int((y_end - y_start + 1)/y_bin)
# Setup acquisition & determine how large a frame is (in pixels).
frame_size = pvc.uns32(0)
region = pvc.rgn_type(x_start, x_end, x_bin, y_start, y_end, y_bin)
check(pvcam.pl_exp_setup_cont(self.hcam,
pvc.uns16(1),
ctypes.byref(region),
pvc.int16(pvc.TIMED_MODE),
pvc.uns32(exposure_time),
ctypes.byref(frame_size),
pvc.int16(pvc.CIRC_OVERWRITE)),
"pl_exp_setup_cont")
# Store frame size in bytes.
#
self.frame_bytes = frame_size.value
# Allocate storage for the frames. Use PVCAM's recommendation for the size.
#
size = self.getParameterDefault("param_frame_buffer_size")
self.data_buffer = numpy.ascontiguousarray(numpy.zeros(size, dtype = numpy.uint8))
self.buffer_len = int(size/self.frame_bytes)
def nameToID(self, pname):
# If this is a name then we need to look it up.
if not isinstance(pname, int):
try:
return pvc.uns32(getattr(pvc, pname.upper()))
except AttributeError:
raise PVCAMException("Unknown parameter " + str(pname))
# Otherwise we assume that it is already an ID.
else:
return pvc.uns32(pname)
def nameToID(self, pname):
# If this is a name then we need to look it up.
if not isinstance(pname, int):
try:
return pvc.uns32(getattr(pvc, pname.upper()))
except AttributeError:
raise PVCAMException("Unknown parameter " + str(pname))
# Otherwise we assume that it is already an ID.
else:
return pvc.uns32(pname)
def __init__(self, camera_name = None, **kwds):
super().__init__(**kwds)
self.buffer_len = None
self.data_buffer = None
self.frame_bytes = None
self.frame_x = None
self.frame_y = None
self.n_captured = pvc.uns32(0) # No more than 4 billion frames in a single capture..
self.n_processed = 0
# Open camera.
c_name = ctypes.c_char_p(camera_name.encode())
self.hcam = pvc.int16(0)
check(pvcam.pl_cam_open(c_name,
ctypes.byref(self.hcam),
pvc.int16(0)),
"pl_cam_open")
# Register our EOF callback. This callback is supposed to increment
# self.n_captured every time the camera acquires a new frame.
#
check(pvcam.pl_cam_register_callback_ex3(self.hcam,
pvc.int32(pvc.PL_CALLBACK_EOF),
eof_callback,
ctypes.byref(self.n_captured)),
"pl_cam_register_callback_ex3")
def __init__(self, camera_name = None, **kwds):
super().__init__(**kwds)
self.buffer_len = None
self.data_buffer = None
self.frame_bytes = None
self.frame_x = None
self.frame_y = None
self.n_captured = pvc.uns32(0) # No more than 4 billion frames in a single capture..
self.n_processed = 0
# Open camera.
c_name = ctypes.c_char_p(camera_name.encode())
self.hcam = pvc.int16(0)
check(pvcam.pl_cam_open(c_name,
ctypes.byref(self.hcam),
pvc.int16(0)),
"pl_cam_open")
# Register our EOF callback. This callback is supposed to increment
# self.n_captured every time the camera acquires a new frame.
#
check(pvcam.pl_cam_register_callback_ex3(self.hcam,
pvc.int32(pvc.PL_CALLBACK_EOF),
eof_callback,
ctypes.byref(self.n_captured)),
"pl_cam_register_callback_ex3")
def startAcquisition(self):
# Reset the acquisition counters.
self.n_captured.value = 0
self.n_processed = 0
# Start the acquisition.
check(pvcam.pl_exp_start_cont(self.hcam,
self.data_buffer.ctypes.data,
pvc.uns32(self.data_buffer.size)),
"pl_exp_start_cont")
def startAcquisition(self):
# Reset the acquisition counters.
self.n_captured.value = 0
self.n_processed = 0
# Start the acquisition.
check(pvcam.pl_exp_start_cont(self.hcam,
self.data_buffer.ctypes.data_as(ctypes.c_void_p),
pvc.uns32(self.data_buffer.size)),
"pl_exp_start_cont")
def startAcquisition(self):
# Reset the acquisition counters.
self.n_captured.value = 0
self.n_processed = 0
# Start the acquisition.
check(pvcam.pl_exp_start_cont(self.hcam,
pvc.ulong64(self.data_buffer.ctypes.data), # This seems to work. Not having ulong64 gave errors: ctypes.ArgumentError: argument 2: <class 'OverflowError'>: int too long to convert
pvc.uns32(self.data_buffer.size)),
"pl_exp_start_cont")
'''
def getParam(self, pid, value, attrib):
"""
Wrapper of pl_get_params, primarily for internal use.
"""
# Overwrite whatever value is for some attributes.
#
if (attrib == pvc.ATTR_ACCESS):
value = pvc.uns16()
elif (attrib == pvc.ATTR_AVAIL):
value = pvc.rs_bool()
elif (attrib == pvc.ATTR_COUNT):
value = pvc.uns32()
elif (attrib == pvc.ATTR_TYPE):
value = pvc.int16()
check(
pvcam.pl_get_param(self.hcam, pid, pvc.int16(attrib),
ctypes.byref(value)), "pl_get_param")
return value.value
def getParam(self, pid, value, attrib):
"""
Wrapper of pl_get_params, primarily for internal use.
"""
# Overwrite whatever value is for some attributes.
#
if (attrib == pvc.ATTR_ACCESS):
value = pvc.uns16()
elif (attrib == pvc.ATTR_AVAIL):
value = pvc.rs_bool()
elif (attrib == pvc.ATTR_COUNT):
value = pvc.uns32()
elif (attrib == pvc.ATTR_TYPE):
value = pvc.int16()
check(pvcam.pl_get_param(self.hcam,
pid,
pvc.int16(attrib),
ctypes.byref(value)),
"pl_get_param")
return value.value
def getTypeInstance(self, ptype):
"""
Return a ctypes instance of ptype.
"""
if (ptype == pvc.TYPE_INT16):
return pvc.int16()
elif (ptype == pvc.TYPE_INT32):
return pvc.int32()
elif (ptype == pvc.TYPE_FLT64):
return pvc.flt64()
elif (ptype == pvc.TYPE_UNS8):
return pvc.uns8()
elif (ptype == pvc.TYPE_UNS16):
return pvc.uns16()
elif (ptype == pvc.TYPE_UNS32):
return pvc.uns32()
elif (ptype == pvc.TYPE_UNS64):
return pvc.ulong64()
elif (ptype == pvc.TYPE_ENUM):
return pvc.int32()
elif (ptype == pvc.TYPE_BOOLEAN):
return pvc.rs_bool()
elif (ptype == pvc.TYPE_INT8):
return pvc.int8()
def getTypeInstance(self, ptype):
"""
Return a ctypes instance of ptype.
"""
if (ptype == pvc.TYPE_INT16):
return pvc.int16()
elif (ptype == pvc.TYPE_INT32):
return pvc.int32()
elif (ptype == pvc.TYPE_FLT64):
return pvc.flt64()
elif (ptype == pvc.TYPE_UNS8):
return pvc.uns8()
elif (ptype == pvc.TYPE_UNS16):
return pvc.uns16()
elif (ptype == pvc.TYPE_UNS32):
return pvc.uns32()
elif (ptype == pvc.TYPE_UNS64):
return pvc.ulong64()
elif (ptype == pvc.TYPE_ENUM):
return pvc.int32()
elif (ptype == pvc.TYPE_BOOLEAN):
return pvc.rs_bool()
elif (ptype == pvc.TYPE_INT8):
return pvc.int8()
