def get_video_format(self, format_index):
"""
Get a string representation of the video format specified by format_index.
format_index must be between 0 and get_video_format_count().
"""
# DLL says need to call this first for it to work
num_vfs = self.get_video_format_count()
if format_index >= num_vfs:
raise IC_Exception(-103)
vf = IC_GrabberDLL.get_video_format(self._handle, c_int(format_index))
if vf is None:
raise IC_Exception(-105)
return vf
def get_video_norm(self, norm_index):
"""
Get a string representation of the video norm specified by norm_index.
norm_index must be between 0 and get_video_norm_count().
:returns: string -- name of video norm of specified index.
"""
# DLL says need to call this first for it to work
num_vns = self.get_video_norm_count()
if norm_index >= num_vns:
raise IC_Exception(-102)
vn = IC_GrabberDLL.get_video_norm(self._handle, c_int(norm_index))
if vn is None:
raise IC_Exception(-104)
return vn
def start_live(self, show_display=False):
"""
Start the live video.
"""
err = IC_GrabberDLL.start_live(self._handle, c_int(int(show_display)))
if err != 1:
raise IC_Exception(err)
def suspend_live(self):
"""
Suspend the live video and put into a prepared state.
"""
err = IC_GrabberDLL.suspend_live(self._handle)
if err != 1:
raise IC_Exception(err)
def wait_til_frame_ready(self, timeout=0):
"""
Wait until the devices announces a frame as being ready.
Requires register_frame_ready_callback() being called.
:param timeout: int -- timeout in milliseconds. Set to 0 for no timeout.
:returns: int -- frame number that was announced as ready.
"""
if timeout:
start = time.clock()
elapsed = (time.clock() - start) * 1000
while not self._frame['ready'] and elapsed < timeout:
time.sleep(0.001)
elapsed = (time.clock() - start) * 1000
else:
while not self._frame['ready']:
time.sleep(0.001)
if self._frame['ready']:
return self._frame['num']
else:
print 'Timed-out'
# return self._frame['num']
raise IC_Exception(-100)
def send_trigger(self):
"""
Send a software trigger to fire the device when in triggered mode.
"""
err = IC_GrabberDLL.software_trigger(self._handle)
if err != 1:
raise IC_Exception(err)
def show_property_dialog(self):
"""
Show property dialog for device.
"""
err = IC_GrabberDLL.show_property_dialog(self._handle)
if err != 1:
raise IC_Exception(err)
def set_format(self, color_format):
"""
"""
err = IC_GrabberDLL.set_format(self._handle, c_int(color_format))
print 'set format err:', err
if err != 1:
raise IC_Exception(err)
def __init__(self, handle, name):
self._handle = handle
self._prop_name = name
self._avail_funcs = { 'video' : IC_GrabberDLL.is_video_property_available,
'camera' : IC_GrabberDLL.is_camera_property_available}
self._auto_avail_funcs = { 'video' : IC_GrabberDLL.is_video_property_auto_available,
'camera' : IC_GrabberDLL.is_camera_property_auto_available}
self._range_funcs = { 'video' : IC_GrabberDLL.video_property_get_range,
'camera' : IC_GrabberDLL.camera_property_get_range}
self._get_value_funcs = { 'video' : IC_GrabberDLL.get_video_property,
'camera' : IC_GrabberDLL.get_camera_property}
self._set_value_funcs = { 'video' : IC_GrabberDLL.set_video_property,
'camera' : IC_GrabberDLL.set_camera_property}
self._get_auto_funcs = { 'video' : IC_GrabberDLL.get_auto_video_property,
'camera' : IC_GrabberDLL.get_auto_camera_property}
self._set_auto_funcs = { 'video' : IC_GrabberDLL.enable_auto_video_property,
'camera' : IC_GrabberDLL.enable_auto_camera_property}
vid_props = IC_Property.get_video_property_names()
cam_props = IC_Property.get_camera_property_names()
if name in vid_props:
self._prop_type = 'video'
self._prop_index = vid_props.index(name)
elif name in cam_props:
self._prop_type = 'camera'
self._prop_index = cam_props.index(name)
else:
raise IC_Exception(0)
def prepare_live(self, show_display=False):
"""
Prepare the device for live video.
"""
err = IC_GrabberDLL.prepare_live(self._handle,
c_int(int(show_display)))
if err != 1:
raise IC_Exception(err)
def open(self):
"""
Open the camera device, required for most functions.
"""
err = IC_GrabberDLL.open_device_by_unique_name(
self._handle, self._unique_device_name)
if err != 1:
raise IC_Exception(err)
def auto(self, aut):
"""
"""
err = self._set_auto_funcs[self._prop_type](self._handle,
c_int(self._prop_index),
c_long(int(aut)))
if err != 1:
raise IC_Exception(err)
def snap_image(self, timeout=1000):
"""
Snap an image. Device must be set to live mode and a format must be set.
:param timeout: int -- time out in milliseconds.
"""
err = IC_GrabberDLL.snap_image(self._handle, c_int(timeout))
if err != 1:
raise IC_Exception(err)
def set_video_norm(self, video_norm):
"""
Sets video norm format, whatver that means.
:param video_norm: string -- video norm to use.
"""
err = IC_GrabberDLL.set_video_norm(self._handle, c_char_p(video_norm))
if err != 1:
raise IC_Exception(err)
def __init__(self, unique_device_name):
self._unique_device_name = unique_device_name
self._handle = IC_GrabberDLL.create_grabber()
if not self._handle:
raise IC_Exception(0)
self._callback_registered = False
self._frame = {'num': -1, 'ready': False}
def set_video_format(self, video_format):
"""
Set a video format for the device. Must be supported.
:param video_format: string -- video format to use.
"""
err = IC_GrabberDLL.set_video_format(self._handle,
c_char_p(video_format))
if err != 1:
raise IC_Exception(err)
def get_video_format_count(self):
"""
Get the number of the available video formats for the current device.
A video capture device must have been opened before this call.
:returns: int -- number of available video formats.
"""
vf_count = IC_GrabberDLL.get_video_format_count(self._handle)
if vf_count < 0:
raise IC_Exception(vf_count)
return vf_count
def auto(self):
"""
"""
aut = c_int()
err = self._get_auto_funcs[self._prop_type](self._handle,
c_int(self._prop_index),
byref(aut))
if err != 1:
raise IC_Exception(err)
else:
return bool(aut.value)
def save_image(self, filename, filetype=1, jpeq_quality=75):
"""
Save the contents of the last snapped image into a file.
:param filename: string -- filename to name saved file.
:param filetype: int -- 0 = BMP, 1 = JPEG.
:param jpeq_quality: int -- JPEG file quality, 0-100.
"""
err = IC_GrabberDLL.save_image(self._handle, c_char_p(filename),
c_int(filetype), c_long(jpeq_quality))
if err != 1:
raise IC_Exception(err)
def value(self):
"""
"""
val = c_long()
err = self._get_value_funcs[self._prop_type](self._handle,
c_int(self._prop_index),
byref(val))
if err != 1:
raise IC_Exception(err)
else:
return val.value
def value(self, val):
"""
"""
# turn off auto first
self.auto = False
# set value
err = self._set_value_funcs[self._prop_type](self._handle,
c_int(self._prop_index),
c_long(val))
if err != 1:
raise IC_Exception(err)
def init_library(self):
"""
Initialise the IC Imaging Control library.
"""
# remember list of unique device names
self._unique_device_names = None
# remember device objects by unique name
self._devices = {}
# no license key needed anymore
err = IC_GrabberDLL.init_library(None)
if err != 1:
raise IC_Exception(err)
def list_video_formats(self):
"""
:returns: list -- available video formats.
"""
vf_list = ((c_char * 80) * 40)()
num_vfs = IC_GrabberDLL.list_video_formats(self._handle,
byref(vf_list), c_int(80))
if num_vfs < 0:
raise IC_Exception(num_vfs)
return_list = []
for vf in vf_list:
if vf.value:
return_list.append(vf.value)
return return_list
def get_image_ptr(self):
"""
Get image buffer from camera.
:returns: ctypes pointer -- pointer to image data.
"""
img_ptr = IC_GrabberDLL.get_image_ptr(self._handle)
if img_ptr is None:
raise IC_Exception(0)
#img_data = cast(img_ptr, POINTER(c_ubyte * buffer_size))
####array = (c_ubyte * iheight * iwidth * 3).from_address(addressof(data.contents))
#array = img_data.contents
return img_ptr
def range(self):
"""
Get valid range of values for the property.
:returns: tuple -- (range min, range max).
"""
rmin = c_long()
rmax = c_long()
err = self._range_funcs[self._prop_type](self._handle,
c_int(self._prop_index),
byref(rmin), byref(rmax))
if err != 1:
raise IC_Exception(err)
else:
return (rmin.value, rmax.value)
def get_unique_device_names(self):
"""
Gets unique names (i.e. model + label + serial) of devices.
:returns: list -- unique devices names.
"""
if self._unique_device_names is None:
# make new list
self._unique_device_names = []
# get num devices, must be called before get_unique_name_from_list()!
num_devices = IC_GrabberDLL.get_device_count()
if num_devices < 0:
raise IC_Exception(num_devices)
# populate list
for i in xrange(num_devices):
self._unique_device_names.append(
IC_GrabberDLL.get_unique_name_from_list(i))
return self._unique_device_names
def get_device(self, unique_device_name):
"""
Gets camera device object based on unique name string.
Will create one only if it doesn't already exist.
:param device_name: string -- the unique name of the device.
:returns: IC_Camera object -- the camera device object requested.
"""
# check name is valid
if unique_device_name in self.get_unique_device_names():
# check if already have a ref to device
if unique_device_name not in self._devices:
# if not, create one
self._devices[unique_device_name] = IC_Camera(
unique_device_name)
return self._devices[unique_device_name]
raise IC_Exception(-106)
def set_frame_rate(self, frame_rate):
"""
"""
err = IC_GrabberDLL.set_frame_rate(self._handle, c_float(frame_rate))
if err != 1:
raise IC_Exception(err)