def _shut_down(self): try: self.cam.close() pvc.uninit_pvcam() return True except BaseException: return False
def main(): # Initialize PVCAM and find the first available camera. pvc.init_pvcam() cam = [cam for cam in Camera.detect_camera()][0] cam.open() cam.speed_table_index = 0 cam.exp_mode = 'Software Trigger Edge' # Start a thread for executing the trigger t1 = TriggerThreadRun(cam) t1.start() # Collect frames in live mode cam.start_live() framesReceived = collectFrames(cam) cam.finish() print('Received live frames: ' + str(framesReceived) + '\n') # Collect frames in sequence mode cam.start_seq(num_frames=NUM_FRAMES) framesReceived = collectFrames(cam) cam.finish() print('Received seq frames: ' + str(framesReceived) + '\n') t1.stop() cam.close() pvc.uninit_pvcam() print('Done')
def main(): # Initialize PVCAM and find the first available camera. pvc.init_pvcam() cam = [cam for cam in Camera.detect_camera()][0] cam.open() cam.start_seq(exp_time=EXPOSE_TIME_ms, num_frames=NUM_FRAMES) # Wait for 3 frames to be captured. Frames take a slightly longer than expose time, so wait a little extra time time.sleep(3 * EXPOSE_TIME_ms * 1e-3 + 0.1) cnt = 0 while cnt < NUM_FRAMES: frame, fps, frame_count = cam.poll_frame(oldestFrame=False) printFrameDetails(frame, fps, frame_count, 'newest') frame, fps, frame_count = cam.poll_frame() printFrameDetails(frame, fps, frame_count, 'oldest') cnt += 1 cam.finish() cam.close() pvc.uninit_pvcam() print('\nTotal frames: {}'.format(cnt))
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() cam.meta_data_enabled = True cam.roi = (0, 1000, 0, 1000) num_frames = 1 cnt = 0 cam.start_seq(exp_time=20, num_frames=num_frames) while cnt < num_frames: frame, fps, frame_count = cam.poll_frame() low = np.amin(frame['pixel_data']) high = np.amax(frame['pixel_data']) average = np.average(frame['pixel_data']) print( 'Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Rate: {:.1f}\tFrame Count: {:.0f}\n' .format(low, high, average, fps, frame_count)) cnt += 1 time.sleep(0.05) cam.finish() cam.close() pvc.uninit_pvcam() print('Total frames: {}\n'.format(cnt))
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() frame = cam.get_frame(exp_time=20).reshape(cam.sensor_size[::-1]) plt.imshow(frame, cmap="gray") plt.show() cam.close() pvc.uninit_pvcam()
def close_cam(cam): ''' Closes the PVCAM instance args: - camera instance ''' try: cam.close() pvc.uninit_pvcam() except: print('Could not close Camera')
def main(): # Initialize PVCAM and find the first available camera. pvc.init_pvcam() cam = [cam for cam in Camera.detect_camera()][0] cam.open() cam.speed_table_index = 0 for i in range(5): frame = cam.get_frame(exp_time=20) print("First five pixels of frame: {}, {}, {}, {}, {}".format( *frame[:5])) cam.close() pvc.uninit_pvcam()
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() NUM_FRAMES = 10 cnt = 0 cam.start_seq(exp_time=20, num_frames=NUM_FRAMES) while cnt < NUM_FRAMES: frame, fps, frame_count = cam.poll_frame() low = np.amin(frame['pixel_data']) high = np.amax(frame['pixel_data']) average = np.average(frame['pixel_data']) print( 'Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Rate: {:.1f}\tFrame Count: {:.0f}\n' .format(low, high, average, fps, frame_count)) cnt += 1 time.sleep(0.05) cam.finish() # Test basic sequence methods frames = cam.get_sequence(NUM_FRAMES) for frame in frames: low = np.amin(frame) high = np.amax(frame) average = np.average(frame) print('Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Count: {:.0f}\n'.format( low, high, average, cnt)) cnt += 1 time_list = [i * 10 for i in range(1, NUM_FRAMES + 1)] frames = cam.get_vtm_sequence(time_list, constants.EXP_RES_ONE_MILLISEC, NUM_FRAMES) for frame in frames: low = np.amin(frame) high = np.amax(frame) average = np.average(frame) print('Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Count: {:.0f}\n'.format( low, high, average, cnt)) cnt += 1 cam.close() pvc.uninit_pvcam() print('Total frames: {}\n'.format(cnt))
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() cam.meta_data_enabled = True cam.set_roi(0, 0, 250, 250) cam.set_roi(300, 100, 400, 900) cam.set_roi(750, 300, 200, 200) NUM_FRAMES = 1 cnt = 0 cam.start_seq(exp_time=20, num_frames=NUM_FRAMES) while cnt < NUM_FRAMES: frame, fps, frame_count = cam.poll_frame() num_rois = len(frame['pixel_data']) for roi_index in range(num_rois): low = np.amin(frame['pixel_data'][roi_index]) high = np.amax(frame['pixel_data'][roi_index]) average = np.average(frame['pixel_data'][roi_index]) s1 = frame['meta_data']['roi_headers'][roi_index]['roi']['s1'] s2 = frame['meta_data']['roi_headers'][roi_index]['roi']['s2'] p1 = frame['meta_data']['roi_headers'][roi_index]['roi']['p1'] p2 = frame['meta_data']['roi_headers'][roi_index]['roi']['p2'] print('ROI:{:2} ({:4}, {:4}) ({:4}, {:4})\tMin:{}\tMax:{}\tAverage:{:.0f}\tFrame Rate: {:.1f}\tFrame Count: {:.0f}'.format(roi_index, s1, p1, s2, p2, low, high, average, fps, frame_count)) alpha = 2.0 # Contrast control (1.0-3.0) beta = 10 # Brightness control (0-100) img = cv2.convertScaleAbs(frame['pixel_data'][roi_index], alpha=alpha, beta=beta) window_name = 'Region: {}'.format(roi_index) cv2.imshow(window_name, img) cv2.moveWindow(window_name, s1, p1) cnt += 1 cv2.waitKey(0) cam.finish() cam.close() pvc.uninit_pvcam() print('Total frames: {}\n'.format(cnt))
def main(): # Initialize PVCAM and find the first available camera. pvc.init_pvcam() cam = [cam for cam in Camera.detect_camera()][0] cam.open() cam.gain = 1 cam.exp_mode = "Timed" cam.binning = 2 #Binning to set camera to collect at #cam.update_mode() cam.exp_out_mode = 0 #cam.speed_table_index = 0 #With the CoolLED pE-300 Ultra in sequence mode, this will cycle through the 3 lamps. t0 = time.time() frame1 = cam.get_frame(exp_time=50) #Exposure channel 1 frame2 = cam.get_frame(exp_time=10) #Exposure channel 2 frame3 = cam.get_frame(exp_time=300) #Exposure channel 3 im_stk = np.zeros((3, frame1.shape[0], frame2.shape[1])) im_stk[0, :, :] = frame1 im_stk[1, :, :] = frame2 im_stk[2, :, :] = frame3 out_file_path = "../../../Desktop/2020_11_13_training_imgs/" from os import listdir from os.path import isfile, join onlyfiles = [ f for f in listdir(out_file_path) if isfile(join(out_file_path, f)) ] leng = onlyfiles.__len__() lenstr = str(leng + 1).zfill(5) tifffile.imsave(out_file_path + 'pos' + lenstr + '.tif', im_stk.astype(np.uint16), imagej=True) t1 = time.time() print(np.round(t1 - t0, 3), "s to acquire") cam.close() pvc.uninit_pvcam() f, axes = plt.subplots(3, 2) axes[0, 0].imshow(frame1, cmap=plt.get_cmap('Blue1')) axes[0, 1].hist(frame1.flatten(), bins=np.arange(0, 65535, 1000)) axes[1, 0].imshow(frame2, cmap=plt.get_cmap('Green1')) axes[1, 1].hist(frame2.flatten(), bins=np.arange(0, 65535, 1000)) axes[2, 0].imshow(frame3, cmap=plt.get_cmap('Red1')) axes[2, 1].hist(frame3.flatten(), bins=np.arange(0, 65535, 1000)) plt.show()
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() cam.start_live(exp_time=20) cnt = 0 tot = 0 t1 = time.time() start = time.time() width = 800 height = int(cam.sensor_size[1] * width / cam.sensor_size[0]) dim = (width, height) fps = 0 while True: frame, fps, frame_count = cam.poll_frame() frame['pixel_data'] = cv2.resize(frame['pixel_data'], dim, interpolation=cv2.INTER_AREA) cv2.imshow('Live Mode', frame['pixel_data']) low = np.amin(frame['pixel_data']) high = np.amax(frame['pixel_data']) average = np.average(frame['pixel_data']) if cnt == 10: t1 = time.time() - t1 fps = 10 / t1 t1 = time.time() cnt = 0 if cv2.waitKey(10) == 27: break print('Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Rate: {:.1f}\n'.format( low, high, average, fps)) cnt += 1 tot += 1 cam.finish() cam.close() pvc.uninit_pvcam() print('Total frames: {}\nAverage fps: {}\n'.format( tot, (tot / (time.time() - start))))
print("Param scan line time is automatically now {0}".format( cam.get_param(const.PARAM_SCAN_LINE_TIME, const.ATTR_CURRENT))) print("Param line delay is automatically now {0}".format( cam.get_param(const.PARAM_SCAN_LINE_DELAY, const.ATTR_CURRENT))) # Get frames and time to sequence start = time.time() frames = cam.get_sequence(num_frames=test_num_frames, exp_time=test_exp_time) end = time.time() # Since numpy's mean can be inaccurate in single precision, computing in float64 instead, which is more accurate sw_mean = np.mean(frames, dtype=np.float64) sw_seq_time = end - start print( "First five rows of frame: {}, {}, {}, {}, {}".format(*frames[0][:5])) print("Mean = {0} ADU".format(sw_mean)) print("Time to sequence = {0}".format(sw_seq_time)) assert sw_seq_time > auto_seq_time_hdr_1, "Auto Mode sequence time was greater than Scan Width sequence time (HDRG1)" else: print("PSM isn't available") cam.close() pvc.uninit_pvcam() print('Finished test')
def uninitPVCAM(): """ Closes the library. """ pvc.uninit_pvcam()
def close(self): iself.cam.close() pvc.uninit_pvcam()
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() cam.meta_data_enabled = True cam.set_roi(0, 0, WIDTH, HEIGHT) cam.start_live(exp_time=100, buffer_frame_count=BUFFER_FRAME_COUNT, stream_to_disk_path=FRAME_DATA_PATH) # Data is streamed to disk in a C++ call-back function invoked directly by PVCAM. To not overburden the system, # only poll for frames in python at a slow rate, then exit when the frame count indicates all frames have been # written to disk while True: frame, fps, frame_count = cam.poll_frame() if frame_count >= NUM_FRAMES: low = np.amin(frame['pixel_data']) high = np.amax(frame['pixel_data']) average = np.average(frame['pixel_data']) print( 'Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Count:{:.0f} Frame Rate: {:.1f}' .format(low, high, average, frame_count, fps)) break time.sleep(1) cam.finish() imageFormat = cam.get_param(const.PARAM_IMAGE_FORMAT) if imageFormat == const.PL_IMAGE_FORMAT_MONO8: BYTES_PER_PIXEL = 1 else: BYTES_PER_PIXEL = 2 cam.close() pvc.uninit_pvcam() # Read out meta data from stored frames FRAME_ALIGNMENT = 0 # Typically 0. 32 for Kinetix PCIe FRAME_BUFFER_ALIGNMENT = 4096 META_DATA_FRAME_HEADER_SIZE = 48 META_DATA_ROI_SIZE = 32 META_DATA_SIZE = META_DATA_FRAME_HEADER_SIZE + META_DATA_ROI_SIZE pixelsPerFrame = WIDTH * HEIGHT bytesPerFrameUnpadded = pixelsPerFrame * BYTES_PER_PIXEL + META_DATA_SIZE framePad = 0 if FRAME_ALIGNMENT == 0 else FRAME_ALIGNMENT - ( bytesPerFrameUnpadded % FRAME_ALIGNMENT) bytesPerFrame = bytesPerFrameUnpadded + framePad frameBufferAlignmentPad = FRAME_BUFFER_ALIGNMENT - ( (BUFFER_FRAME_COUNT * bytesPerFrame) % FRAME_BUFFER_ALIGNMENT) with open(FRAME_DATA_PATH, "rb") as f: badMetaDataCount = 0 for frame_index in range(NUM_FRAMES): frame_number = frame_index + 1 # Read frame number from meta data header # Every time the circular buffer wraps around, bytes are padded into the file. This is a result of needing to # write data in chunks that are multiples of the alignment boundary. frameBufferPad = int( frame_index / BUFFER_FRAME_COUNT) * frameBufferAlignmentPad FRAME_NUMBER_OFFSET = 5 filePos = frame_index * bytesPerFrame + FRAME_NUMBER_OFFSET + frameBufferPad f.seek(filePos, 0) frameNumberBytes = f.read(4) frame_number_meta_data = int.from_bytes(frameNumberBytes, 'little') if frame_number != frame_number_meta_data: badMetaDataCount += 1 print('Expected: ' + str(frame_number) + ' Observed: ' + str(frame_number_meta_data)) print('Verified ' + str(NUM_FRAMES) + ' frames:') print(' Meta data errors: ' + str(badMetaDataCount)) if badMetaDataCount > 0: print('\nMeta data error troubleshooting:') print(' 1. Verify FRAME_ALIGNMENT for camera and interface') print(' 2. Increase exposure time')
def main(): pvc.init_pvcam() cam = next(Camera.detect_camera()) cam.open() cnt = 0 # Check status from sequence collect cam.start_seq(exp_time=1000, num_frames=2) acquisitionInProgress = True while acquisitionInProgress: frameStatus = cam.check_frame_status() print('Seq frame status: ' + frameStatus) if frameStatus == 'READOUT_NOT_ACTIVE' or frameStatus == 'FRAME_AVAILABLE' or frameStatus == 'READOUT_COMPLETE' or frameStatus == 'READOUT_FAILED': acquisitionInProgress = False if acquisitionInProgress: time.sleep(0.05) if frameStatus != 'READOUT_FAILED': frame, fps, frame_count = cam.poll_frame() low = np.amin(frame['pixel_data']) high = np.amax(frame['pixel_data']) average = np.average(frame['pixel_data']) print( 'Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Rate: {:.1f}\tFrame Count: {:.0f}' .format(low, high, average, fps, frame_count)) cam.finish() frameStatus = cam.check_frame_status() print('Seq post-acquisition frame status: ' + frameStatus + '\n') # Check status from live collect. Status will only report FRAME_AVAILABLE between acquisitions, so an indeterminate number of frames are needed # before we catch the FRAME_AVAILABLE status cam.start_live(exp_time=10) acquisitionInProgress = True while acquisitionInProgress: frameStatus = cam.check_frame_status() print('Live frame status: ' + frameStatus) if frameStatus == 'READOUT_NOT_ACTIVE' or frameStatus == 'FRAME_AVAILABLE' or frameStatus == 'READOUT_FAILED': acquisitionInProgress = False if acquisitionInProgress: time.sleep(0.05) if frameStatus != 'READOUT_FAILED': frame, fps, frame_count = cam.poll_frame() low = np.amin(frame['pixel_data']) high = np.amax(frame['pixel_data']) average = np.average(frame['pixel_data']) print( 'Min:{}\tMax:{}\tAverage:{:.0f}\tFrame Rate: {:.1f}\tFrame Count: {:.0f}' .format(low, high, average, fps, frame_count)) cam.finish() frameStatus = cam.check_frame_status() print('Live post-acquisition frame status: ' + frameStatus) cam.close() pvc.uninit_pvcam()
def tearDown(self): # if self.test_cam.is_open(): # self.test_cam.close() pvc.uninit_pvcam()