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 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 stopAcquisition(self): """ Stop the current acquisition and tell the camera to go to the idle state. """ check(pvcam.pl_exp_stop_cont(self.hcam, pvc.int16(pvc.CCS_HALT)), "pl_exp_stop_cont")
def getCameraNames(): """ Return a list of all the available cameras. """ # Query to get the total number of cameras. n_cams = pvc.int16() check(pvcam.pl_cam_get_total(ctypes.byref(n_cams)), "pl_cam_get_total") # Query the camera names. cam_name = ctypes.c_char_p((' ' * pvc.CAM_NAME_LEN).encode()) camera_names = [] for i in range(n_cams.value): check(pvcam.pl_cam_get_name(pvc.int16(i), cam_name), "pl_cam_get_name") camera_names.append(cam_name.value.decode("ascii")) return camera_names
def getParameter(self, pname, attr_type): """ Returns the current value of a parameter. pname - The parameters ID or name. """ pid = self.nameToID(pname) ptype = self.getParameterType(pid) # Get value for numbers. value = self.getTypeInstance(ptype) if value is not None: return self.getParam(pid, value, attr_type) # Get value for strings. if (ptype == pvc.TYPE_CHAR_PTR): # Get the string. count = self.getParameterCount(pname) cstring = ctypes.c_char_p((' ' * count).encode()) check(pvcam.pl_get_param(self.hcam, pid, pvc.int16(attr_type), cstring), "pl_get_param") return cstring.value.decode() raise PVCAMException("getParameter: unsupported type " + str(ptype))
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()