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