# -*- coding: utf-8 -*-
"""
Photonic Science GEVSCMOS
=========================
Driver for Photonic Science Cameras (Pleora GEV). This driver was originally written by Perceval Guillou
<perceval@photonic-science.com>, in Py2 and has been successfully tested with scmoscontrol.dll SCMOS Pleora (GEV)
control dll (x86 )v5.6.0.0 (date modified 10/2/2013)
This version copyright: Sanli Faez <s.faez@uu.nl>
.. todo:: The coding style is not in line with the rest of PyNTA. The GEVSMOS class can be cleaned up and documented
"""
import ctypes as C
import os
import sys
from sys import platform
if platform == "linux" or platform == "linux2":
pass
elif platform == "darwin":
pass
elif platform == "win32":
from _ctypes import LoadLibrary, FreeLibrary
import numpy
NUMPY_MODES = {"L": numpy.uint8, "I;16": numpy.uint16}
[docs]class GEVSCMOS:
def __init__(self, cwd_path, name):
self.cwd_path = cwd_path # working directory
self.name = name # Monitor name = folder where DLL and settings are stored
self.setup_file = "%s\\%s\\PSL_camera_files\\ps_setup.dat" % (cwd_path, name)
self.dll_name = self.GetDLL()
self.dll = None
self.LoadCamDLL()
self.ResetOptions()
def __str__(self):
msg = "Monitor setting located in %s" % (self.setup_file)
return msg
[docs] def GetDLL(self):
FileList = os.listdir('%s\\%s' % (self.cwd_path, self.name))
count = 0
for file in FileList:
if file[-4:] == ".dll":
dll_name = file
count += 1
if count == 0:
msg = "Check in '%s'\n!!!CAMERA CONTROL DLL NOT FOUND!!!" % self.cwd_path
print (msg)
return ""
elif count > 1:
msg = "Check in '%s'\n!!!ONLY ONE DLL FILE MUST EXIST IN THE CAMERA FOLDER!!!" % self.cwd_path
print (msg)
return ""
else:
return dll_name
[docs] def LoadCamDLL(self):
self.libHandle = LoadLibrary('%s\\%s\\%s' % (self.cwd_path, self.name, self.dll_name))
# self.libHandle = C.windll.kernel32.LoadLibraryA('%s\\%s\\%s'%(self.cwd_path,self.name,self.dll_name))
self.dll = C.CDLL(None, handle=self.libHandle) # cdecl
# self.dll = C.WinDLL(None, handle=self.libHandle) #stdcall
# self.dll = C.CDLL('%s\\%s\\%s'%(self.cwd_path,self.name,self.dll_name))
self.InitFunctions()
[docs] def UnloadCamDLL(self):
del self.dll
self.dll = None
FreeLibrary(self.libHandle)
# C.windll.kernel32.FreeLibrary(self.libHandle)
[docs] def ResetOptions(self):
self.mode = "I;16"
self.size = (0, 0)
self.sizemax = (1919, 1079)
self.state = 0
self.abort_flag = False
self.remapping = False
self.smooth = False
self.clip = True
self.SubArea = (0, 0, 0, 0)
self.SoftBin = (1, 1)
self.gainmode = 0
self.expous = 100000
self.FlatAverage = 10
self.GlobalRemap = False
self.tempread = True
# self.is2tap = False
# 0 = gain mode 1 - 16 bit
# 1 = gain mode 2 - 16 bit
# 2 = gain mode 10 - 16 bit
# 3 = gain mode 30 - 16 bit
# 4 = combined (1 and 30) in software - 24 => Demangle => 16 bit
# 5 = combined in hardware - 16 bit
# 6 = gain mode 1 - 8 bit
# 7 = gain mode 2 - 8 bit
# 8 = gain mode 10 - 8 bit
# 9 = gain mode 30 - 8 bit
# 10= combined in hardware - 8bit
if self.IsInCamCor():
if self.Has8bitGainModes():
gainmodes = ['gain1', 'gain2', 'gain10', 'gain30', 'gain1+30_Hardware', 'gain1_8b', 'gain2_8b',
'gain10_8b', 'gain30_8b', 'gain1+30_8b']
else:
gainmodes = ['gain1', 'gain2', 'gain10', 'gain30', 'gain1+30_Hardware']
else:
if self.Has8bitGainModes():
gainmodes = ['gain1', 'gain2', 'gain10', 'gain30', 'gain1+30', 'gain1_8b', 'gain2_8b', 'gain10_8b',
'gain30_8b']
else:
gainmodes = ['gain1', 'gain2', 'gain10', 'gain30', 'gain1+30']
if self.HasClockSpeedLimit():
clockspeedmodes = ['50MHz']
else:
clockspeedmodes = ['50MHz', '100MHz'] # ,'200MHz'
# self.flipdata = self.IsFlipped()
self.Options = {
'TriggerMode': ['FreeRunning', 'Software',
'Hardware_Falling', 'Hardware_Rising'],
'ClockSpeedMode': clockspeedmodes,
'GainMode': gainmodes,
'PowerSavingMode': ['PowerOn', 'PowerOff', 'CoolingOff'],
# 'VideoGain' :[0,100],
'IntensifierGain': [1, 100],
# 'ChipGain' :[1,100],
'SoftBin': [(1, 1), (1040, 1040)],
'SubArea': [(0, 0, 0, 0)],
'Exposure': [(100, 'Millisec'), (4294967, ['Microsec', 'Millisec', 'Second'])],
'Temperature': [0, 0],
'Offset': [1],
'BrightPixel': [1],
'FlatField': [0],
'MakeFlat': [None],
'FlatAverage': [10, 1000],
'Remapping': [0],
'Smooth': [0],
'Clip': [0],
'Sharpening': [0],
'AutoLevel': [0],
'ALC_maxexp': [1000, 65535],
'ALC_win': [(0, 0, 1919, 1079)],
'BestFit': [0],
'BF_Peek': [1000, 65535],
'IF_delay': [0, 65535],
'BinningFilter': [0],
'AutoBinning': [0],
'Gamma': [0],
'GammaPeak': [0, 100],
'GammaBright': [0, 100],
# 'FlickerMode' :['Off','50MHz','60MHz'],
}
[docs] def InitFunctions(self):
# Buffer
self.dll.PSL_VHR_get_image_pointer.restype = C.POINTER(C.c_char) # ushort
self.dll.PSL_VHR_demangle_rgb24_into_16bit_image.restype = C.POINTER(C.c_char) # ushort
self.dll.PSL_VHR_remap_image.restype = C.POINTER(C.c_char) # ushort
self.dll.PSL_VHR_get_pointer_to_safebufferA.restype = C.POINTER(C.c_char) # ushort
self.dll.PSL_VHR_get_pointer_to_safebufferB.restype = C.POINTER(C.c_char) # ushort
self.dll.PSL_VHR_get_pointer_to_safebufferC.restype = C.POINTER(C.c_char) # ushort
# Bool
self.dll.PSL_VHR_Open.restype = C.c_bool
self.dll.PSL_VHR_open_map.restype = C.c_bool
self.dll.PSL_VHR_Close.restype = C.c_bool
self.dll.PSL_VHR_set_gain_mode.restype = C.c_bool
self.dll.PSL_VHR_set_speed.restype = C.c_bool
self.dll.PSL_VHR_set_video_gain.restype = C.c_bool
self.dll.PSL_VHR_set_chip_gain.restype = C.c_bool
self.dll.PSL_VHR_set_exposure.restype = C.c_bool
self.dll.PSL_VHR_set_trigger_mode.restype = C.c_bool
self.dll.PSL_VHR_set_sub_area_coordinates.restype = C.c_bool
self.dll.PSL_VHR_enable_offset_subtraction.restype = C.c_bool
self.dll.PSL_VHR_enable_bright_pixel_correction.restype = C.c_bool
self.dll.PSL_VHR_enable_flat_field_correction.restype = C.c_bool
self.dll.PSL_VHR_Snap_and_return.restype = C.c_bool
self.dll.PSL_VHR_Get_snap_status.restype = C.c_bool
self.dll.PSL_VHR_abort_snap.restype = C.c_bool
self.dll.PSL_VHR_apply_post_snap_processing.restype = C.c_bool
self.dll.PSL_VHR_enable_gamma.restype = C.c_bool
self.dll.PSL_VHR_set_gamma_gain_bright.restype = C.c_bool
self.dll.PSL_VHR_set_gamma_gain_brightness.restype = C.c_bool
# self.dll.PSL_VHR_set_flicker_mode.restype = C.c_bool
[docs] def IsInCamCor(self):
isincamcor = 0
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option.lower() in ["onboardcorrectionssupported", "incameracorrections"]:
isincamcor = int(value)
break
except:
pass
return bool(isincamcor)
[docs] def IsFlipped(self):
isflip = 0
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option.lower() in ["swflipimage"]:
isflip = int(value)
break
except:
pass
return bool(isflip)
[docs] def GetRemapSize(self):
remapsize = None
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
Nx, Ny = (0, 0)
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option in ["Submapwidth", "submapwidth"]:
Nx = int(value)
if option in ["Submapheight", "submapheight"]:
Ny = int(value)
break
remapsize = Nx, Ny
except:
pass
# print "remap size is (%s,%s)"%remapsize
return remapsize
[docs] def HasIntensifier(self):
intensifier_value = 1
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option in ["intensifiergaincanbeset", "IntensifierGainCanBeSet", "HasIntensifier", "hasintensifier"]:
intensifier_value = int(value)
break
except:
pass
return bool(intensifier_value)
[docs] def HasTemperature(self):
tempset = None
tempread = None
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option in ["TemperatureCanBeSet", "temperaturecanbeset"]:
tempset = int(value)
if option in ["TemperatureCanBeRead", "temperaturecanberead"]:
tempread = int(value)
if tempset == 1:
return [-30, 50]
elif tempset == 0:
return [0, 0]
elif tempread == 1:
return [0, 0]
elif tempread == 0:
return None
else:
return [-30, 50]
except:
return [-30, 50]
[docs] def HasHPMapping(self):
use_hpm_remap = 0
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option in ["viewer_use_hp_mapping"]:
use_hpm_remap = int(value)
break
except:
print ("HasHPMapping: %s: %s" % (sys.exc_info()[0], sys.exc_info()[1]))
return bool(use_hpm_remap)
[docs] def HasBinning(self):
use_binning = 1
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option in ["binning_supported"]:
use_binning = int(value)
break
except:
print ("HasBinning: %s: %s" % (sys.exc_info()[0], sys.exc_info()[1]))
return bool(use_binning)
[docs] def HasClockSpeedLimit(self):
clockspeedlimit = 0
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option.lower() in ["hasclockspeedlimit", "clockspeedlimit"]:
clockspeedlimit = int(value)
break
except:
pass
return bool(clockspeedlimit)
[docs] def Has8bitGainModes(self):
has8bit = 1
try:
fich = open(self.setup_file, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option.lower() in ["remove_8bit_gainmodes"]:
if int(value) == 0:
has8bit = 1
else:
has8bit = 0
break
except:
pass
return bool(has8bit)
# ------ CAMERA PROPERTIES ---------------------------------
[docs] def GetName(self):
return self.name
[docs] def GetDLLName(self):
return self.dll_name
[docs] def GetMode(self):
return self.mode
[docs] def GetState(self):
return self.state
[docs] def GetPedestal(self):
return self.pedestal
[docs] def GetOptions(self):
return self.Options.keys()
[docs] def GetSize(self):
return self.size
[docs] def GetSizeMax(self):
return self.sizemax
[docs] def UpdateSizeMax(self):
Nx = self.dll.PSL_VHR_get_maximum_width()
Ny = self.dll.PSL_VHR_get_maximum_height()
self.sizemax = (Nx, Ny)
return self.sizemax
[docs] def UpdateSize(self):
Nx = self.dll.PSL_VHR_get_width()
Ny = self.dll.PSL_VHR_get_height()
self.size = (Nx, Ny)
# ----- Specificities -----------------------------------------------------------------
[docs] def SelectIportDevice(self):
path = "%s\\%s\\IPconf.dat" % (self.cwd_path, self.name)
if os.path.exists(path):
self.IP_add = ""
self.mac_add = ""
self.IsIport = True
fich = open(path, 'r')
lines = fich.readlines()
fich.close()
for line in lines:
(option, sep, value) = line.strip().partition('=')
if option == "MAC":
self.mac_add = value
elif option == "IP":
self.IP_add = value
if self.mac_add == "" or self.IP_add == "":
self.dll.PSL_VHR_select_IPORT_device("", "")
else:
self.dll.PSL_VHR_select_IPORT_device(self.mac_add, "[%s]" % self.IP_add)
return True
else:
self.IsIport = False
return False
# -------- CAMERA STANTARD FUNCTIONS ------------------
[docs] def Open(self):
path = "%s\\%s\\PSL_camera_files" % (self.cwd_path, self.name)
self.SelectIportDevice()
if self.dll.PSL_VHR_Open(str(path)):
if not self.OpenMap():
# del self.Options['Remapping']
pass
if not self.IsIntensifier():
del self.Options['IntensifierGain']
Temp = self.HasTemperature()
if Temp == None:
self.tempread = False
else:
self.tempread = True
(Nx, Ny) = self.UpdateSizeMax()
self.Options["SubArea"][0] = (0, 0, Nx - 1, Ny - 1)
self.Options["ALC_win"][0] = (0, 0, Nx - 1, Ny - 1)
self.SetSubArea(0, 0, Nx - 1, Ny - 1)
self.UpdateSize()
return 0
else:
return 1
[docs] def Close(self):
self.dll.PSL_VHR_Close()
self.UnloadCamDLL()
[docs] def SetSubArea(self, left, top, right, bottom):
self.SubArea = (left, top, right, bottom)
rep = self.dll.PSL_VHR_set_sub_area_coordinates(left, right, top, bottom)
self.UpdateSize()
return rep
[docs] def SetSoftBin(self, Sx, Sy):
self.SoftBin = (Sx, Sy)
[docs] def SetExposure(self, expo, unit):
if unit == "Second":
self.expous = expo * 1000000
elif unit == "Millisec":
self.expous = expo * 1000
elif unit == "Microsec":
self.expous = expo
ans = self.dll.PSL_VHR_set_exposure(self.expous)
# print "SetExposure ",self.name,expo,unit,self.expous,type(self.expous),ans
return ans
[docs] def SetTrigger(self, mode):
if mode == "FreeRunning":
return self.dll.PSL_VHR_set_trigger_mode(0)
elif mode == "Software":
return self.dll.PSL_VHR_set_trigger_mode(1)
elif mode == "Hardware_Falling":
return self.dll.PSL_VHR_set_trigger_mode(2)
elif mode == "Hardware_Rising":
return self.dll.PSL_VHR_set_trigger_mode(6)
elif mode == "Pipeline_Master":
return self.dll.PSL_VHR_set_trigger_mode(16)
elif mode == "Pipeline_Slave":
return self.dll.PSL_VHR_set_trigger_mode(18)
else:
return "Trigger mode not valid"
[docs] def SetGainMode(self, mode):
# 0 = gain mode 1 - 16 bit
# 1 = gain mode 2 - 16 bit
# 2 = gain mode 10 - 16 bit
# 3 = gain mode 30 - 16 bit
# 4 = combined (1 and 30) in software - 24 => Demangle => 16 bit
# 5 = combined in hardware - 16 bit
# 6 = gain mode 1 - 8 bit
# 7 = gain mode 2 - 8 bit
# 8 = gain mode 10 - 8 bit
# 9 = gain mode 30 - 8 bit
# 10= combined in hardware - 8bit
if mode == 'gain1':
self.gainmode = 0
rep = self.dll.PSL_VHR_set_gain_mode(0)
elif mode == 'gain2':
self.gainmode = 1
rep = self.dll.PSL_VHR_set_gain_mode(1)
elif mode == 'gain10':
self.gainmode = 2
rep = self.dll.PSL_VHR_set_gain_mode(2)
elif mode == 'gain30':
self.gainmode = 3
rep = self.dll.PSL_VHR_set_gain_mode(3)
elif mode == 'gain1+30':
self.gainmode = 4
rep = self.dll.PSL_VHR_set_gain_mode(4)
elif mode == 'gain1+30_Hardware':
self.gainmode = 5
rep = self.dll.PSL_VHR_set_gain_mode(5)
elif mode == 'gain1_8b':
self.gainmode = 6
rep = self.dll.PSL_VHR_set_gain_mode(6)
elif mode == 'gain2_8b':
self.gainmode = 7
rep = self.dll.PSL_VHR_set_gain_mode(7)
elif mode == 'gain10_8b':
self.gainmode = 8
rep = self.dll.PSL_VHR_set_gain_mode(8)
elif mode == 'gain30_8b':
self.gainmode = 9
rep = self.dll.PSL_VHR_set_gain_mode(9)
elif mode == 'gain1+30_8b':
self.gainmode = 10
rep = self.dll.PSL_VHR_set_gain_mode(10)
else:
rep = "Gain mode not valid"
if self.gainmode in [0, 1, 2, 3, 4, 5]:
self.mode = "I;16"
elif self.gainmode in [6, 7, 8, 9, 10]:
self.mode = "L"
self.UpdateSize()
return rep
[docs] def SetVideoGain(self, gain):
return self.dll.PSL_VHR_set_video_gain(gain)
[docs] def SetChipGain(self, gain):
return self.dll.PSL_VHR_set_chip_gain(gain)
[docs] def IsIntensifier(self):
return self.HasIntensifier()
[docs] def SetIntensifierGain(self, gain): # SetChipGain
return self.dll.PSL_VHR_set_chip_gain(gain)
[docs] def SetClockSpeed(self, mode):
if mode == '200MHz':
return self.dll.PSL_VHR_set_speed(2)
elif mode == '100MHz':
return self.dll.PSL_VHR_set_speed(1)
elif mode == '50MHz':
return self.dll.PSL_VHR_set_speed(0)
else:
return False
[docs] def GetTemperature(self):
try:
if self.tempread:
return self.dll.PSL_VHR_read_CCD_temperature()
else:
return None
except:
return None
[docs] def SetTemperature(self, temp):
return False
[docs] def SetPowerSavingMode(self, mode):
try:
if mode == 'PowerOn':
return self.dll.PSL_VHR_set_power_saving_mode(1)
elif mode == 'PowerOff':
return self.dll.PSL_VHR_set_power_saving_mode(0)
elif mode == 'CoolingOff':
return self.dll.PSL_VHR_set_power_saving_mode(2)
except:
print ("Cannot apply PowerSavingMode %s" % mode)
# -------- IMAGE ACQUISITION--------------------------------
[docs] def Snap(self):
self.state = 1
self.abort_flag = False
rep = self.dll.PSL_VHR_Snap_and_return()
while not self.dll.PSL_VHR_Get_snap_status():
pass
self.state = 0
return rep
[docs] def SnapAndReturn(self):
self.abort_flag = False
rep = self.dll.PSL_VHR_Snap_and_return()
return rep
[docs] def GetStatus(self):
return self.dll.PSL_VHR_Get_snap_status()
[docs] def AbortSnap(self):
self.abort_flag = True
self.state = 0
return self.dll.PSL_VHR_abort_snap()
[docs] def GetImagePointer(self):
imp = self.dll.PSL_VHR_get_image_pointer()
self.dll.PSL_VHR_transfer_to_safebufferC(imp)
return self.dll.PSL_VHR_get_pointer_to_safebufferC()
[docs] def GetRawImage(self):
imp = self.GetImagePointer()
(Nx, Ny) = self.GetSize()
if self.gainmode in [0, 1, 2, 3]:
depth = 2
elif self.gainmode == 4:
depth = 3
else:
depth = 1
return ((Nx, Ny), imp[0:depth * Nx * Ny])
[docs] def GetImage(self, imp=None):
if imp == None:
imp = self.GetImagePointer()
(Nx, Ny) = self.GetSize()
if self.gainmode in [0, 1, 2, 3]:
self.dll.PSL_VHR_apply_post_snap_processing(imp)
depth = 2
elif self.gainmode == 4:
(Nx, Ny), imp = self.Demangle(imp, Nx, Ny)
depth = 2
elif self.gainmode == 5:
self.dll.PSL_VHR_apply_post_snap_processing(imp)
depth = 2
elif self.gainmode in [6, 7, 8, 9, 10]:
depth = 1
if self.remapping and not self.GlobalRemap:
(Nx, Ny), imp = self.Remap(imp, Nx, Ny)
if self.SoftBin != (1, 1):
Nx, Ny = self.SoftBinImage(imp, Nx, Ny)
return ((Nx, Ny), imp[0:depth * Nx * Ny])
# -------- CAMERA CORRECTION FUNCTIONS -------------
[docs] def SoftBinImage(self, image_pointer, Nx, Ny):
newX = C.c_int(Nx)
newY = C.c_int(Ny)
Sx, Sy = self.SoftBin
if self.gainmode in [6, 7, 8, 9, 10]:
self.dll.PSL_VHR_software_bin_8bit_image(image_pointer, C.byref(newX), C.byref(newY), Sx, Sy)
else:
self.dll.PSL_VHR_software_bin_image(image_pointer, C.byref(newX), C.byref(newY), Sx, Sy)
Nx, Ny = newX.value, newY.value
return (Nx, Ny)
[docs] def OpenMap(self, file_name="distortion.map"):
return self.dll.PSL_VHR_open_map(file_name)
[docs] def Remap(self, image_pointer, Nx, Ny):
newX = C.c_int(Nx)
newY = C.c_int(Ny)
# if self.is2tap:
# imp = self.dll.PSL_VHR_remap_double_image(image_pointer,C.byref(newX),C.byref(newY),self.smooth, self.clip)
# else:
imp = self.dll.PSL_VHR_remap_image(image_pointer, C.byref(newX), C.byref(newY), self.smooth, self.clip)
return ((newX.value, newY.value), imp)
[docs] def Demangle(self, image_pointer, Nx, Ny):
newX = C.c_int(Nx)
newY = C.c_int(Ny)
imp = self.dll.PSL_VHR_demangle_rgb24_into_16bit_image(image_pointer, C.byref(newX), C.byref(newY))
return ((newX.value, newY.value), imp)
[docs] def EnableRemapping(self, enable):
self.remapping = enable
return True
[docs] def EnableSmooth(self, enable):
self.smooth = bool(enable)
return True
[docs] def EnableClip(self, enable):
self.clip = bool(enable)
return True
[docs] def EnableOffset(self, enable):
return self.dll.PSL_VHR_enable_offset_subtraction(enable)
[docs] def EnableBrightPixel(self, enable):
return self.dll.PSL_VHR_enable_bright_pixel_correction(enable)
[docs] def EnableFlatField(self, enable):
return self.dll.PSL_VHR_enable_flat_field_correction(enable)
[docs] def MakeFlatField(self):
try:
if self.dll.PSL_VHR_generate_flat_field_image(self.FlatAverage):
return True
else:
return False
except:
return False
[docs] def SetFlatAverage(self, average_number):
self.FlatAverage = average_number
return True
[docs] def EnableStreaming(self, enable):
self.dll.PSL_VHR_enable_image_streaming(C.c_bool(enable))
# print "Streaming",enable,self
return True
[docs] def InitSequence(self, imnum):
self.SeqLen = imnum
self.dll.PSL_VHR_initialise_sequence_storage(C.c_uint(self.SeqLen))
[docs] def SnapSequence(self):
self.dll.PSL_VHR_snap_sequence(C.c_uint(self.SeqLen))
[docs] def GetSequencePointer(self, id):
self.PSL_VHR_get_sequence_image_pointer(C.byref(self.safe), C.c_uint(id))
return self.safe
[docs] def FreeSequence(self):
self.dll.PSL_VHR_free_sequence_storage()
[docs] def SaveSequence(self):
self.dll.PSL_VHR_save_sequence_as_multiple_flf_files(C.c_uint(self.SeqLen))
[docs] def EnableSharpening(self, enable):
self.dll.PSL_VHR_enable_sharpening(enable)
return True
[docs] def EnableAutoLevel(self, enable):
self.dll.PSL_VHR_enable_ALC(enable)
return True
[docs] def SetALCMaxExp(self, maxexp):
self.dll.PSL_VHR_set_ALC_max_exp(maxexp)
return True
[docs] def SetALCWin(self, l, t, r, b):
self.dll.PSL_VHR_set_ALC_window_coords(l, t, r, b)
return True
[docs] def EnableBestFit(self, enable):
self.dll.PSL_VHR_enable_bestfit(enable)
return True
[docs] def SetBFPeek(self, peek):
self.dll.PSL_VHR_set_bestfit_peek(peek)
return True
[docs] def SetIFDelay(self, delay):
self.dll.PSL_VHR_set_delay_between_images(delay)
return True
[docs] def EnableBinningFilter(self, enable):
try:
self.dll.PSL_VHR_enable_binning_filter(enable)
return True
except:
return False
[docs] def AutoBinningFilter(self, enable):
try:
self.dll.PSL_VHR_enable_auto_binning_filter(enable)
return True
except:
return False
[docs] def EnableGamma(self, enable):
return self.dll.PSL_VHR_enable_gamma(enable)
[docs] def SetGammaPeak(self, value):
return self.dll.PSL_VHR_set_gamma_gain_bright(value)
[docs] def SetGammaBright(self, value):
return self.dll.PSL_VHR_set_gamma_gain_brightness(value)
[docs] def SetFlickerMode(self, value):
if value == "Off":
return self.dll.PSL_VHR_set_flicker_mode(0)
elif value == "50MHz":
return self.dll.PSL_VHR_set_flicker_mode(1)
elif value == "60MHz":
return self.dll.PSL_VHR_set_flicker_mode(2)
if __name__ == '__main__':
from PIL import Image
import numpy
NUMPY_MODES = {"L": numpy.uint8, "I;16": numpy.uint16}
def PILfromArray(newarr, mode='I;16'):
return Image.fromarray(newarr, mode)
def arrayFromBuffer(data, size, mode='I;16'):
w, h = size
return numpy.frombuffer(data, NUMPY_MODES[mode]).reshape((h, w))
cam = GEVSCMOS(".", "SCMOS")
cam.Open()
# ======= Init camera setup
cam.SetClockSpeed('50MHz')
cam.SetGainMode("gain1")
cam.SetTrigger("FreeRunning")
cam.EnableAutoLevel(0)
cam.SetExposure(2, "Millisec")
# ======= Acquire Image
cam.Snap()
# cam.Snap()
size, data = cam.GetImage()
mode = cam.GetMode()
# ====== Buffer to Numpy array
arry = arrayFromBuffer(data, size)
arry8 = arry * (255 / 65535.)
arry8 = arry8.astype(numpy.uint8)
# ======== Array to PIL Image
pil16 = PILfromArray(arry, mode) # 16bit image
pil8 = PILfromArray(arry8, 'L') # 8bit image
# save the images
# pil16.save("test16.tiff")
pil8.show()
pil8.save("test8.tiff")
cam.Close()