def print_enumeration_node_and_current_entry(node, level): """ This function retrieves and prints the display names of an enumeration node and its current entry (which is actually housed in another node unto itself). :param node: Node to get information from. :type node: INode :param level: Depth to indent output. :type level: int :return: True if successful, False otherwise. :rtype: bool """ try: result = True # Create enumeration node node_enumeration = PySpin.CEnumerationPtr(node) # Retrieve current entry as enumeration node # # *** NOTES *** # Enumeration nodes have three methods to differentiate between: first, # GetIntValue() returns the integer value of the current entry node; # second, GetCurrentEntry() returns the entry node itself; and third, # ToString() returns the symbolic of the current entry. node_enum_entry = PySpin.CEnumEntryPtr( node_enumeration.GetCurrentEntry()) # Get display name display_name = node_enumeration.GetDisplayName() # Retrieve current symbolic # # *** NOTES *** # Rather than retrieving the current entry node and then retrieving its # symbolic, this could have been taken care of in one step by using the # enumeration node's ToString() method. entry_symbolic = node_enum_entry.GetSymbolic() # Print current entry symbolic print_with_indent(level, "%s: %s" % (display_name, entry_symbolic)) except PySpin.SpinnakerException as ex: print "Error: %s" % ex return False return result
def acquire_and_display_images(cam, number): result = True nodemap_tldevice = cam.GetTLDeviceNodeMap() cam.Init() nodemap = cam.GetNodeMap() node_acquisition_mode = PySpin.CEnumerationPtr(nodemap.GetNode('AcquisitionMode')) node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName('Continuous') acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue() node_acquisition_mode.SetIntValue(acquisition_mode_continuous) cam.BeginAcquisition() node_device_serial_number = PySpin.CStringPtr(nodemap_tldevice.GetNode('DeviceSerialNumber')) image_result = cam.GetNextImage(1000) image_data = image_result.GetNDArray() cv2.imshow(str(number),image_data) cv2.waitKey(1) image_result.Release() cam.EndAcquisition() return True
def acquire_and_display_images(cam, nodemap, nodemap_tldevice): """ This function continuously acquires images from a device and display them in a GUI. :param cam: Camera to acquire images from. :param nodemap: Device nodemap. :param nodemap_tldevice: Transport layer device nodemap. :type cam: CameraPtr :type nodemap: INodeMap :type nodemap_tldevice: INodeMap :return: True if successful, False otherwise. :rtype: bool """ global continue_recording sNodemap = cam.GetTLStreamNodeMap() # Change bufferhandling mode to NewestOnly node_bufferhandling_mode = PySpin.CEnumerationPtr( sNodemap.GetNode('StreamBufferHandlingMode')) if not PySpin.IsAvailable( node_bufferhandling_mode) or not PySpin.IsWritable( node_bufferhandling_mode): print('Unable to set stream buffer handling mode.. Aborting...') return False # Retrieve entry node from enumeration node node_newestonly = node_bufferhandling_mode.GetEntryByName('NewestOnly') if not PySpin.IsAvailable(node_newestonly) or not PySpin.IsReadable( node_newestonly): print('Unable to set stream buffer handling mode.. Aborting...') return False # Retrieve integer value from entry node node_newestonly_mode = node_newestonly.GetValue() # Set integer value from entry node as new value of enumeration node node_bufferhandling_mode.SetIntValue(node_newestonly_mode) print('*** IMAGE ACQUISITION ***\n') try: node_acquisition_mode = PySpin.CEnumerationPtr( nodemap.GetNode('AcquisitionMode')) if not PySpin.IsAvailable( node_acquisition_mode) or not PySpin.IsWritable( node_acquisition_mode): print( 'Unable to set acquisition mode to continuous (enum retrieval). Aborting...' ) return False # Retrieve entry node from enumeration node node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName( 'Continuous') if not PySpin.IsAvailable( node_acquisition_mode_continuous) or not PySpin.IsReadable( node_acquisition_mode_continuous): print( 'Unable to set acquisition mode to continuous (entry retrieval). Aborting...' ) return False # Retrieve integer value from entry node acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue( ) # Set integer value from entry node as new value of enumeration node node_acquisition_mode.SetIntValue(acquisition_mode_continuous) print('Acquisition mode set to continuous...') # Begin acquiring images # # *** NOTES *** # What happens when the camera begins acquiring images depends on the # acquisition mode. Single frame captures only a single image, multi # frame catures a set number of images, and continuous captures a # continuous stream of images. # # *** LATER *** # Image acquisition must be ended when no more images are needed. cam.BeginAcquisition() print('Acquiring images...') # Retrieve device serial number for filename # # *** NOTES *** # The device serial number is retrieved in order to keep cameras from # overwriting one another. Grabbing image IDs could also accomplish # this. device_serial_number = '' node_device_serial_number = PySpin.CStringPtr( nodemap_tldevice.GetNode('DeviceSerialNumber')) if PySpin.IsAvailable(node_device_serial_number) and PySpin.IsReadable( node_device_serial_number): device_serial_number = node_device_serial_number.GetValue() print('Device serial number retrieved as %s...' % device_serial_number) # Close program print('Press enter to close the program..') # Figure(1) is default so you can omit this line. Figure(0) will create a new window every time program hits this line fig = plt.figure(1) # Close the GUI when close event happens fig.canvas.mpl_connect('close_event', handle_close) # Retrieve and display images while (continue_recording): try: # Retrieve next received image # # *** NOTES *** # Capturing an image houses images on the camera buffer. Trying # to capture an image that does not exist will hang the camera. # # *** LATER *** # Once an image from the buffer is saved and/or no longer # needed, the image must be released in order to keep the # buffer from filling up. image_result = cam.GetNextImage(1000) # Ensure image completion if image_result.IsIncomplete(): print('Image incomplete with image status %d ...' % image_result.GetImageStatus()) else: # Getting the image data as a numpy array image_data = image_result.GetNDArray() # Draws an image on the current figure plt.imshow(image_data, cmap='gray') # Interval in plt.pause(interval) determines how fast the images are displayed in a GUI # Interval is in seconds. plt.pause(0.001) # Clear current reference of a figure. This will improve display speed significantly plt.clf() # If user presses enter, close the program if keyboard.is_pressed('ENTER'): print('Program is closing...') # Close figure plt.close('all') input('Done! Press Enter to exit...') continue_recording = False # Release image # # *** NOTES *** # Images retrieved directly from the camera (i.e. non-converted # images) need to be released in order to keep from filling the # buffer. image_result.Release() except PySpin.SpinnakerException as ex: print('Error: %s' % ex) return False # End acquisition # # *** NOTES *** # Ending acquisition appropriately helps ensure that devices clean up # properly and do not need to be power-cycled to maintain integrity. cam.EndAcquisition() except PySpin.SpinnakerException as ex: print('Error: %s' % ex) return False return True
def acquire_images(cam_list): """ This function acquires and saves 10 images from each device. :param cam_list: List of cameras :type cam_list: CameraList :return: True if successful, False otherwise. :rtype: bool """ print('*** IMAGE ACQUISITION ***\n') try: result = True # Prepare each camera to acquire images # # *** NOTES *** # For pseudo-simultaneous streaming, each camera is prepared as if it # were just one, but in a loop. Notice that cameras are selected with # an index. We demonstrate pseduo-simultaneous streaming because true # simultaneous streaming would require multiple process or threads, # which is too complex for an example. # for i, cam in enumerate(cam_list): # Set acquisition mode to continuous node_acquisition_mode = PySpin.CEnumerationPtr( cam.GetNodeMap().GetNode('AcquisitionMode')) if not PySpin.IsAvailable( node_acquisition_mode) or not PySpin.IsWritable( node_acquisition_mode): print( 'Unable to set acquisition mode to continuous (node retrieval; camera %d). Aborting... \n' % i) return False node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName( 'Continuous') if not PySpin.IsAvailable( node_acquisition_mode_continuous) or not PySpin.IsReadable( node_acquisition_mode_continuous): print( 'Unable to set acquisition mode to continuous (entry \'continuous\' retrieval %d). \ Aborting... \n' % i) return False acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue( ) node_acquisition_mode.SetIntValue(acquisition_mode_continuous) print('Camera %d acquisition mode set to continuous...' % i) # Begin acquiring images cam.BeginAcquisition() print('Camera %d started acquiring images...' % i) print() # Retrieve, convert, and save images for each camera # # *** NOTES *** # In order to work with simultaneous camera streams, nested loops are # needed. It is important that the inner loop be the one iterating # through the cameras; otherwise, all images will be grabbed from a # single camera before grabbing any images from another. for n in range(NUM_IMAGES): for i, cam in enumerate(cam_list): try: # Retrieve device serial number for filename node_device_serial_number = PySpin.CStringPtr( cam.GetTLDeviceNodeMap().GetNode('DeviceSerialNumber')) if PySpin.IsAvailable( node_device_serial_number) and PySpin.IsReadable( node_device_serial_number): device_serial_number = node_device_serial_number.GetValue( ) print('Camera %d serial number set to %s...' % (i, device_serial_number)) # Retrieve next received image and ensure image completion image_result = cam.GetNextImage(1000) if image_result.IsIncomplete(): print('Image incomplete with image status %d ... \n' % image_result.GetImageStatus()) else: # Print image information width = image_result.GetWidth() height = image_result.GetHeight() print( 'Camera %d grabbed image %d, width = %d, height = %d' % (i, n, width, height)) # Convert image to mono 8 image_converted = image_result.Convert( PySpin.PixelFormat_Mono8, PySpin.HQ_LINEAR) # Create a unique filename if device_serial_number: filename = 'AcquisitionMultipleCamera-%s-%d.jpg' % ( device_serial_number, n) else: filename = 'AcquisitionMultipleCamera-%d-%d.jpg' % ( i, n) # Save image image_converted.Save(filename) print('Image saved at %s' % filename) # Release image image_result.Release() print() except PySpin.SpinnakerException as ex: print('Error: %s' % ex) result = False # End acquisition for each camera # # *** NOTES *** # Notice that what is usually a one-step process is now two steps # because of the additional step of selecting the camera. It is worth # repeating that camera selection needs to be done once per loop. # # It is possible to interact with cameras through the camera list with # GetByIndex(); this is an alternative to retrieving cameras as # CameraPtr objects that can be quick and easy for small tasks. for cam in cam_list: # End acquisition cam.EndAcquisition() except PySpin.SpinnakerException as ex: print('Error: %s' % ex) result = False return result
def acquire_images(cam, nodemap, nodemap_tldevice): """ This function acquires and saves 10 images from a device. :param cam: Camera to acquire images from. :param nodemap: Device nodemap. :param nodemap_tldevice: Transport layer device nodemap. :type cam: CameraPtr :type nodemap: INodeMap :type nodemap_tldevice: INodeMap :return: True if successful, False otherwise. :rtype: bool """ print('*** IMAGE ACQUISITION ***\n') try: result = True # Set acquisition mode to continuous # # *** NOTES *** # Because the example acquires and saves 10 images, setting acquisition # mode to continuous lets the example finish. If set to single frame # or multiframe (at a lower number of images), the example would just # hang. This would happen because the example has been written to # acquire 10 images while the camera would have been programmed to # retrieve less than that. # # Setting the value of an enumeration node is slightly more complicated # than other node types. Two nodes must be retrieved: first, the # enumeration node is retrieved from the nodemap; and second, the entry # node is retrieved from the enumeration node. The integer value of the # entry node is then set as the new value of the enumeration node. # # Notice that both the enumeration and the entry nodes are checked for # availability and readability/writability. Enumeration nodes are # generally readable and writable whereas their entry nodes are only # ever readable. # # Retrieve enumeration node from nodemap # In order to access the node entries, they have to be casted to a pointer type (CEnumerationPtr here) node_acquisition_mode = PySpin.CEnumerationPtr(nodemap.GetNode('AcquisitionMode')) if not PySpin.IsAvailable(node_acquisition_mode) or not PySpin.IsWritable(node_acquisition_mode): print('Unable to set acquisition mode to continuous (enum retrieval). Aborting...') return False # Retrieve entry node from enumeration node node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName('Continuous') if not PySpin.IsAvailable(node_acquisition_mode_continuous) or not PySpin.IsReadable(node_acquisition_mode_continuous): print('Unable to set acquisition mode to continuous (entry retrieval). Aborting...') return False # Retrieve integer value from entry node acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue() # Set integer value from entry node as new value of enumeration node node_acquisition_mode.SetIntValue(acquisition_mode_continuous) print('Acquisition mode set to continuous...') # Begin acquiring images # # *** NOTES *** # What happens when the camera begins acquiring images depends on the # acquisition mode. Single frame captures only a single image, multi # frame catures a set number of images, and continuous captures a # continuous stream of images. Because the example calls for the # retrieval of 10 images, continuous mode has been set. # # *** LATER *** # Image acquisition must be ended when no more images are needed. cam.BeginAcquisition() print('Acquiring images...') # Retrieve device serial number for filename # # *** NOTES *** # The device serial number is retrieved in order to keep cameras from # overwriting one another. Grabbing image IDs could also accomplish # this. device_serial_number = '' node_device_serial_number = PySpin.CStringPtr(nodemap_tldevice.GetNode('DeviceSerialNumber')) if PySpin.IsAvailable(node_device_serial_number) and PySpin.IsReadable(node_device_serial_number): device_serial_number = node_device_serial_number.GetValue() print('Device serial number retrieved as %s...' % device_serial_number) # Retrieve, convert, and save images for i in range(NUM_IMAGES): try: # Retrieve next received image # # *** NOTES *** # Capturing an image houses images on the camera buffer. Trying # to capture an image that does not exist will hang the camera. # # *** LATER *** # Once an image from the buffer is saved and/or no longer # needed, the image must be released in order to keep the # buffer from filling up. image_result = cam.GetNextImage(1000) # Ensure image completion # # *** NOTES *** # Images can easily be checked for completion. This should be # done whenever a complete image is expected or required. # Further, check image status for a little more insight into # why an image is incomplete. if image_result.IsIncomplete(): print('Image incomplete with image status %d ...' % image_result.GetImageStatus()) else: # Print image information; height and width recorded in pixels # # *** NOTES *** # Images have quite a bit of available metadata including # things such as CRC, image status, and offset values, to # name a few. width = image_result.GetWidth() height = image_result.GetHeight() print('Grabbed Image %d, width = %d, height = %d' % (i, width, height)) # Convert image to mono 8 # # *** NOTES *** # Images can be converted between pixel formats by using # the appropriate enumeration value. Unlike the original # image, the converted one does not need to be released as # it does not affect the camera buffer. # # When converting images, color processing algorithm is an # optional parameter. image_converted = image_result.Convert(PySpin.PixelFormat_Mono8, PySpin.HQ_LINEAR) # Create a unique filename if device_serial_number: filename = 'Acquisition-%s-%d.jpg' % (device_serial_number, i) else: # if serial number is empty filename = 'Acquisition-%d.jpg' % i # Save image # # *** NOTES *** # The standard practice of the examples is to use device # serial numbers to keep images of one device from # overwriting those of another. image_converted.Save(filename) print('Image saved at %s' % filename) # Release image # # *** NOTES *** # Images retrieved directly from the camera (i.e. non-converted # images) need to be released in order to keep from filling the # buffer. image_result.Release() print('') except PySpin.SpinnakerException as ex: print('Error: %s' % ex) return False # End acquisition # # *** NOTES *** # Ending acquisition appropriately helps ensure that devices clean up # properly and do not need to be power-cycled to maintain integrity. cam.EndAcquisition() except PySpin.SpinnakerException as ex: print('Error: %s' % ex) return False return result