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)
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]
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)
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]
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(PVCAMCamera, self).__init__(**kwds)
self.buffer_len = None
self.data_buffer = None
self.frame_size = 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)
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(PVCAMCamera, self).__init__(**kwds)
self.buffer_len = None
self.data_buffer = None
self.frame_size = 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)
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(2 * 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,
pvc.uns32(2*self.data_buffer.size)),
"pl_exp_start_cont")
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 = (x_end - x_start) / x_bin
self.frame_y = (y_end - y_start) / 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),
cytpes.byref(frame_size),
pvc.int16(pvc.CIRC_OVERWRITE)),
"pl_exp_setup_cont")
# This assumes that we are dealing with a 16 bit camera.
# We should verify that it is the same self.frame_x * self.frame_y?
#
self.frame_size = frame_size.value / 2
# Allocate storage for the frames. For now we'll just allocate storage
# for 100 frames, but it would be better to have this depend on the
# exposure time (i.e. enough frames to buffer 2 seconds or something).
#
# Note: The PVCAM library limits the maximum buffer size to 2**32 bytes.
#
self.buffer_len = 100
size = self.buffer_len * self.frame_size
self.data_buffer = numpy.ascontiguousarray(
numpy.empty(size, dtype=numpy.uint16))
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 = (x_end - x_start)/x_bin
self.frame_y = (y_end - y_start)/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),
cytpes.byref(frame_size),
pvc.int16(pvc.CIRC_OVERWRITE)),
"pl_exp_setup_cont")
# This assumes that we are dealing with a 16 bit camera.
# We should verify that it is the same self.frame_x * self.frame_y?
#
self.frame_size = frame_size.value/2
# Allocate storage for the frames. For now we'll just allocate storage
# for 100 frames, but it would be better to have this depend on the
# exposure time (i.e. enough frames to buffer 2 seconds or something).
#
# Note: The PVCAM library limits the maximum buffer size to 2**32 bytes.
#
self.buffer_len = 100
size = self.buffer_len * self.frame_size
self.data_buffer = numpy.ascontiguousarray(numpy.empty(size, dtype = numpy.uint16))
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.uns64()
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.uns64()
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()