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