def saveImage(self):
ueye.is_AllocImageMem(self.hcam, self.sensorinfo.nMaxWidth, self.sensorinfo.nMaxHeight, 24, self.pccmem,
self.memID)
ueye.is_SetImageMem(self.hcam, self.pccmem, self.memID)
ueye.is_SetDisplayPos(self.hcam, 100, 100)
self.nret = ueye.is_FreezeVideo(self.hcam, ueye.IS_WAIT)
self.rawImageTimeStamp = datetime.datetime.now()
self.imageTimeStamp = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S')
self.imageName = 'imagem_%s.jpg' % self.imageTimeStamp
self.imagePath = self.operationConfigs['savingDirectory'] + self.imageName
# self.imagePath = self.operationConfigs['savingDirectory'] + "tmp.jpg"
self.FileParams = ueye.IMAGE_FILE_PARAMS()
self.FileParams.pwchFileName = self.imagePath
self.FileParams.nFileType = ueye.IS_IMG_BMP
self.FileParams.ppcImageMem = None
self.FileParams.pnImageID = None
self.nret = ueye.is_ImageFile(self.hcam, ueye.IS_IMAGE_FILE_CMD_SAVE, self.FileParams,
ueye.sizeof(self.FileParams))
ueye.is_FreeImageMem(self.hcam, self.pccmem, self.memID)
#sleep(.01)
#ueye.is_ExitCamera(self.hcam)
self.image = np.uint8(ndimage.imread(self.imagePath, flatten=True))
self.image = self.crop_end(self.image, 0, 100)
def getCurrentFrame(self):
nRet = ueye.is_FreezeVideo(self.hCam, ueye.IS_WAIT)
if nRet != ueye.IS_SUCCESS:
print("is_GetCameraInfo ERROR")
# Enables the queue mode for existing image memory sequences
nRet = ueye.is_InquireImageMem(self.hCam, self.pcImageMemory,
self.MemID, self.width, self.height,
self.nBitsPerPixel, self.pitch)
if nRet != ueye.IS_SUCCESS:
print("is_InquireImageMem ERROR")
print("getting image")
array = ueye.get_data(self.pcImageMemory,
self.width,
self.height,
self.nBitsPerPixel,
self.pitch,
copy=False)
frame = np.reshape(
array, (self.height.value, self.width.value, self.bytes_per_pixel))
print(frame.shape)
coadd = np.zeros(frame.shape[0:2]).astype('float')
#coadd[:,:] = (frame[:,:,1]*255).astype('float')+frame[:,:,0].astype('float')
coadd[:, :] = frame[:, :,
1].astype('float') * 255 + frame[:, :,
0].astype('float')
return coadd
def freeze_video(self, wait=False):
"""
Freeze the video capturing.
Parameters
==========
wait: boolean
To wait or not for the camera frames (default to False).
"""
wait_param = ueye.IS_WAIT if wait else ueye.IS_DONT_WAIT
return ueye.is_FreezeVideo(self.h_cam, wait_param)
def capture(self):
'''
Takes an image from the camera and places it in the computer memory
'''
err = pue.is_FreezeVideo(
self.cam,
pue.IS_WAIT) #IS_DONT_WAIT = 0x0000, or IS_GET_LIVE = 0x8000
if err != pue.IS_SUCCESS:
raise CameraException(self.cam, 'ueye>capture>', err, False)
err = pue.is_CopyImageMem(self.cam, self.ppcImgMem, self.pid,
self.image_data.ctypes.data)
if err != pue.IS_SUCCESS:
raise CameraException(self.cam, 'ueye>capture>', err, False)
def StartExposure(self):
logger.debug('StartAq')
if self._poll:
# stop, we'll allocate buffers and restart
self.StopAq()
# allocate at least 2 seconds of buffers
buffer_size = int(max(2 * self.GetFPS(), 50))
self.InitBuffers(buffer_size, buffer_size)
event_log.logEvent('StartAq', '')
if self._cont_mode:
self.check_success(ueye.is_CaptureVideo(self.h, ueye.IS_DONT_WAIT))
else:
self.check_success(ueye.is_FreezeVideo(self.h, ueye.IS_DONT_WAIT))
return 0
def saveImage(self):
try:
time1 = datetime.datetime.now()
ueye.is_AllocImageMem(self.hcam, self.sensorinfo.nMaxWidth,
self.sensorinfo.nMaxHeight, 24, self.pccmem,
self.memID)
ueye.is_SetImageMem(self.hcam, self.pccmem, self.memID)
ueye.is_SetDisplayPos(self.hcam, 100, 100)
self.nret = ueye.is_FreezeVideo(self.hcam, ueye.IS_WAIT)
self.imageTimeStamp = datetime.datetime.now().strftime(
'%Y_%m_%d_%H_%M_%S')
self.imageName = 'imagem_%s.jpg' % self.imageTimeStamp
self.imagePath = self.operationConfigs[
'savingDirectory'] + self.imageName
self.FileParams = ueye.IMAGE_FILE_PARAMS()
self.FileParams.pwchFileName = self.imagePath
self.FileParams.nFileType = ueye.IS_IMG_BMP
self.FileParams.ppcImageMem = None
self.FileParams.pnImageID = None
self.nret = ueye.is_ImageFile(self.hcam,
ueye.IS_IMAGE_FILE_CMD_SAVE,
self.FileParams,
ueye.sizeof(self.FileParams))
ueye.is_FreeImageMem(self.hcam, self.pccmem, self.memID)
sleep(.01)
ueye.is_ExitCamera(self.hcam)
time2 = datetime.datetime.now()
elapsed_time = time2 - time1
logging.info('Saved: {}! Elasped time (ms): {}'.format(
self.imageName, elapsed_time.microseconds / 1000))
self.pijuice.status.SetLedBlink('D2', 2, [0, 255, 0], 50,
[0, 255, 0], 50)
sleep(.1)
self.pijuice.status.SetLedState('D2', [0, 0, 0])
except:
logging.warning('NOT SAVED: {}!\n'.format(self.imageName))
self.pijuice.status.SetLedBlink('D2', 2, [255, 0, 0], 50,
[255, 0, 0], 50)
sleep(.1)
self.pijuice.status.SetLedState('D2', [0, 0, 0])
pass
def saveImage(self):
# try:
time1 = datetime.datetime.now()
ueye.is_AllocImageMem(self.hcam, self.sensorinfo.nMaxWidth,
self.sensorinfo.nMaxHeight, 24, self.pccmem,
self.memID)
ueye.is_SetImageMem(self.hcam, self.pccmem, self.memID)
ueye.is_SetDisplayPos(self.hcam, 100, 100)
self.nret = ueye.is_FreezeVideo(self.hcam, ueye.IS_WAIT)
self.rawImageTimeStamp = datetime.datetime.now()
self.imageTimeStamp = datetime.datetime.now().strftime(
'%Y_%m_%d_%H_%M_%S')
self.imageName = 'imagem_%s.jpg' % self.imageTimeStamp
self.imagePath = self.operationConfigs[
'savingDirectory'] + self.imageName
# self.imagePath = self.operationConfigs['savingDirectory'] + "tmp.jpg"
self.FileParams = ueye.IMAGE_FILE_PARAMS()
self.FileParams.pwchFileName = self.imagePath
self.FileParams.nFileType = ueye.IS_IMG_BMP
self.FileParams.ppcImageMem = None
self.FileParams.pnImageID = None
self.nret = ueye.is_ImageFile(self.hcam, ueye.IS_IMAGE_FILE_CMD_SAVE,
self.FileParams,
ueye.sizeof(self.FileParams))
ueye.is_FreeImageMem(self.hcam, self.pccmem, self.memID)
sleep(.01)
ueye.is_ExitCamera(self.hcam)
# self.image = np.ones((self.sensorinfo.nMaxHeight.value, self.sensorinfo.nMaxWidth.value), dtype=np.uint8)
# ueye.is_CopyImageMem(self.hcam, self.pccmem, self.memID, self.image.ctypes.data)
self.image = np.uint8(ndimage.imread(self.imagePath, flatten=True))
time2 = datetime.datetime.now()
elapsed_time = time2 - time1
logging.info('Saved: {}! Elasped time (s): {}'.format(
self.imageName, elapsed_time.total_seconds()))
def saveImage(self):
try:
time1 = datetime.datetime.now()
ueye.is_AllocImageMem(self.hcam, self.sensorinfo.nMaxWidth,
self.sensorinfo.nMaxHeight, 24, self.pccmem,
self.memID)
ueye.is_SetImageMem(self.hcam, self.pccmem, self.memID)
ueye.is_SetDisplayPos(self.hcam, 100, 100)
self.nret = ueye.is_FreezeVideo(self.hcam, ueye.IS_WAIT)
self.imageTimeStamp = datetime.datetime.now().strftime(
'%Y_%m_%d_%H_%M_%S')
self.imageName = 'imagem_%s.jpg' % self.imageTimeStamp
self.imagePath = self.savingDirectory + self.imageName
self.FileParams = ueye.IMAGE_FILE_PARAMS()
self.FileParams.pwchFileName = self.imagePath
self.FileParams.nFileType = ueye.IS_IMG_BMP
self.FileParams.ppcImageMem = None
self.FileParams.pnImageID = None
self.nret = ueye.is_ImageFile(self.hcam,
ueye.IS_IMAGE_FILE_CMD_SAVE,
self.FileParams,
ueye.sizeof(self.FileParams))
# print(nret)
ueye.is_FreeImageMem(self.hcam, self.pccmem, self.memID)
sleep(.1)
ueye.is_ExitCamera(self.hcam)
time2 = datetime.datetime.now()
elapsed_time = time2 - time1
# print('Elasped time (s): {}'.format(elapsed_time))
print('Image saved at {}! Elasped time (ms) {}'.format(
self.imageTimeStamp, elapsed_time.microseconds / 1000))
except:
print('Image not saved at {}!\n'.format(self.imageTimeStamp))
pass
def acquisition_oneshot(self, timeout_ms=1000):
nRet = ueye.is_EnableEvent(self.hCam, ueye.IS_SET_EVENT_FRAME)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("is_EnableEvent ERROR")
nRet = ueye.is_FreezeVideo(self.hCam, ueye.IS_DONT_WAIT)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("is_CaptureVideo ERROR")
nRet = ueye.is_WaitEvent(self.hCam, ueye.IS_SET_EVENT_FRAME,
timeout_ms)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("is_WaitEvent ERROR")
nRet = ueye.is_InquireImageMem(
self.hCam,
self.pcImageMemory,
self.MemID,
self.width,
self.height,
self.nBitsPerPixel,
self.pitch,
)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("is_InquireImageMem ERROR")
array = ueye.get_data(
self.pcImageMemory,
self.width,
self.height,
self.nBitsPerPixel,
self.pitch,
copy=True,
)
nRet = ueye.is_DisableEvent(self.hCam, ueye.IS_SET_EVENT_FRAME)
if nRet != ueye.IS_SUCCESS:
raise RuntimeError("is_DisableEvent ERROR")
return array.reshape((self.height.value, self.width.value))
def freeze_video(self, wait=False):
wait_param = ueye.IS_WAIT if wait else ueye.IS_DONT_WAIT
return ueye.is_FreezeVideo(self.h_cam, wait_param)
else:
print("Press q to leave the program")
a=20
a=ueye.DOUBLE(30)
c=ueye.DOUBLE()
b=ueye.UINT(8)
thing=ueye.is_Exposure(hCam,ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, a,b )
thing=ueye.is_Exposure(hCam,ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, c,b )
print(c)
gain=ueye.UINT(80)
thingy=ueye.is_SetHardwareGain(hCam,gain, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER, ueye.IS_IGNORE_PARAMETER)
#---------------------------------------------------------------------------------------------------------------------------------------
nRet = ueye.is_FreezeVideo(hCam, ueye.IS_WAIT)
Iinfo=ueye.UEYEIMAGEINFO()
n=1
while(nRet == ueye.IS_SUCCESS):
# In order to display the image in an OpenCV window we need to...
# ...extract the data of our image memory
array = ueye.get_data(pcImageMemory, width, height, nBitsPerPixel, pitch, copy=False)
# bytes_per_pixel = int(nBitsPerPixel / 8)
# ...reshape it in an numpy array...
frame = np.reshape(array,(height.value, width.value, bytes_per_pixel))
pccmem, memID)
ueye.is_SetImageMem(hcam, pccmem, memID)
ueye.is_SetExternalTrigger(hcam, ueye.IS_SET_TRIGGER_SOFTWARE)
wertSet = ueye.c_double(1)
nret = ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, wertSet,
ueye.sizeof(wertSet))
print(wertSet)
help(ueye.is_Exposure)
wert = ueye.c_double()
sizeo = ueye.sizeof(wert)
nret = ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, wert, sizeo)
print(wert)
nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT)
print(nret)
FileParams = ueye.IMAGE_FILE_PARAMS()
FileParams.pwchFileName = "c:\python-test-image.png"
FileParams.nFileType = ueye.IS_IMG_PNG
FileParams.ppcImageMem = None
FileParams.pnImageID = None
nret = ueye.is_ImageFile(hcam, ueye.IS_IMAGE_FILE_CMD_SAVE, FileParams,
ueye.sizeof(FileParams))
print(nret)
nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT)
print(nret)
FileParams = ueye.IMAGE_FILE_PARAMS()
FileParams.pwchFileName = "c:\python-test-image1.png"
FileParams.nFileType = ueye.IS_IMG_PNG
def main():
cam = ueye.HIDS() # open first available cam
check(ueye.is_InitCamera(cam, None))
# query image size
size = ueye.IS_SIZE_2D()
check((ueye.is_AOI(cam, ueye.IS_AOI_IMAGE_GET_SIZE, size,
ueye.sizeof(size))))
width = size.s32Width
height = size.s32Height
# allocate memory. we need at least one buffer
mem_ptr = ueye.c_mem_p()
mem_id = ueye.INT()
bits_per_pixel = ueye.INT(24) # assume we have 24 bits per pixel (rgb)
check(
ueye.is_AllocImageMem(cam, width, height, bits_per_pixel, mem_ptr,
mem_id))
# set the image mem active, so we can render into
check(ueye.is_SetImageMem(cam, mem_ptr, mem_id))
# we need to get the mem pitch for later usage
pitch = ueye.INT()
check(
ueye.is_InquireImageMem(cam, mem_ptr, mem_id, width, height,
bits_per_pixel, pitch))
#expMax = ueye.DOUBLE(0.0)
expMax = [10, 20, 30, 40]
# now lets capture a contineous video
while True:
# For loop
for i in my_range(0, 4, 1):
if i == 4:
break
# print("i= ",expMax[i])
timeExp = ueye.DOUBLE(expMax[i])
check(
ueye.is_Exposure(cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
timeExp, ueye.sizeof(timeExp)))
print("Set Exposure :", timeExp)
time.sleep(1)
# lets capture one image
check(ueye.is_FreezeVideo(cam, ueye.IS_WAIT))
# for this we use a function from the pyueye interface get data
array = ueye.get_data(mem_ptr,
width,
height,
bits_per_pixel,
pitch,
copy=False) # we do not want to copy
# print(array)
# we have to reshape the array
frame = np.reshape(array, (height.value, width.value, 3))
# print(frame)
framesmall = cv2.resize(frame, (0, 0), fx=0.3, fy=0.3)
time.sleep(1)
#cv2.imshow('img', framesmall)
# Save image OpenCV
cv2.imwrite("img_" + str(expMax[i]) + 'ms.jpg', frame)
print("save image to file: " + "img_" + str(expMax[i]) + 'ms.jpg')
# if the 'q' key is pressed, stop the loop
key = cv2.waitKey(1) & 0xFF
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# we have to free our image mem at the end
check(ueye.is_FreeImageMem(cam, mem_ptr, mem_id))
check(ueye.is_ExitCamera(cam))
def UEye420_Snapper(Exposure, Gain, File_Location, pixel_clock):
from pyueye import ueye
import ctypes
import time
saved = False
while saved == False:
#CCD Settings and Start-Up
hcam = ueye.HIDS(0)
pccmem = ueye.c_mem_p()
memID = ueye.c_int()
hWnd = ctypes.c_voidp()
ueye.is_InitCamera(hcam, hWnd)
ueye.is_SetDisplayMode(hcam, 0)
sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(hcam, sensorinfo)
ueye.is_AllocImageMem(hcam, sensorinfo.nMaxWidth,
sensorinfo.nMaxHeight, 24, pccmem, memID)
ueye.is_SetImageMem(hcam, pccmem, memID)
ueye.is_SetDisplayPos(hcam, 100, 100)
PIXELCLOCK_CMD_SET = 6
PIXELCLOCK_CMD_GET = 4
pixel = ctypes.c_uint(pixel_clock)
ueye.is_PixelClock(hcam, PIXELCLOCK_CMD_SET, pixel,
ctypes.sizeof(pixel))
print('PX=', pixel)
exposure_time = ctypes.c_double(
Exposure) #Exposure time in miliseconds
value = ctypes.c_int(Gain)
ueye.is_SetHWGainFactor(hcam, ueye.IS_SET_MASTER_GAIN_FACTOR, value)
ueye.is_Exposure(hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
exposure_time, ctypes.sizeof(ctypes.c_double))
print('Exposure (ms) =', exposure_time)
print('Gain = ', Gain)
time.sleep(float(Exposure * 1e-4) * 1.0 +
0.2) #Some time for CCD to set new exposure time
#initially set to float(Exposure*1e-4)*1.0+1.0 and it works then
nret = ueye.is_FreezeVideo(hcam, ueye.IS_WAIT) #Freeze/Snap
#Save Parameters
FileParams = ueye.IMAGE_FILE_PARAMS()
FileParams.pwchFileName = (File_Location)
FileParams.nFileType = ueye.IS_IMG_BMP
FileParams.ppcImageMem = None
FileParams.pnImageID = None
#IF nret is '1' Image is not saved if nret is "0" Image is saved
nret = ueye.is_ImageFile(hcam, ueye.IS_IMAGE_FILE_CMD_SAVE, FileParams,
ueye.sizeof(FileParams))
if nret == 0:
saved = True
print('Image Saved!')
if nret == 1:
print('Error Image is not Saved!')
#Shutting the CCD-Down.
ueye.is_FreeImageMem(hcam, pccmem, memID)
ueye.is_ExitCamera(hcam)
def capture_image(self):
""" In order to preserve compatibility with the old version, this function returns (R , G1 , G1 , B) images in the form of dictionary. """
time.sleep(0.25)
if self.frames_avg == 1:
ueye.is_AllocImageMem(self.CamID, self.sensorWidth_ctype,
self.sensorHeight_ctype, self.bitdepth,
self.memPointer, self.memID)
ueye.is_SetImageMem(self.CamID, self.memPointer, self.memID)
imageArray = np.zeros(
(self.sensorHeight_ctype.value, self.sensorWidth_ctype.value),
dtype=np.uint16)
ueye.is_FreezeVideo(self.CamID, ueye.IS_WAIT)
ueye.is_CopyImageMem(self.CamID, self.memPointer, self.memID,
imageArray.ctypes.data)
# Clean memory
ueye.is_FreeImageMem(self.CamID, self.memPointer, self.memID)
else:
imageStack = []
print('(' + str(self.frames_avg) + 'x) ', end='')
for i in range(self.frames_avg):
ueye.is_AllocImageMem(self.CamID, self.sensorWidth_ctype,
self.sensorHeight_ctype, self.bitdepth,
self.memPointer, self.memID)
ueye.is_SetImageMem(self.CamID, self.memPointer, self.memID)
imageArrayFrame = np.zeros((self.sensorHeight_ctype.value,
self.sensorWidth_ctype.value),
dtype=np.uint16)
ueye.is_FreezeVideo(self.CamID, ueye.IS_WAIT)
ueye.is_CopyImageMem(self.CamID, self.memPointer, self.memID,
imageArrayFrame.ctypes.data)
# Clean memory
ueye.is_FreeImageMem(self.CamID, self.memPointer, self.memID)
imageStack.append(np.array(imageArrayFrame, dtype=np.uint16))
imageArray = np.mean(imageStack, axis=0)
#Binning Recuting
if self.binningEnabled == True:
imageArray = imageArray[0:self.currentHeight, 0:self.currentWidth]
#imageArrayResized = self.resizeImage(imageArray)
if self.sensorInfo.strSensorName.decode('utf8')[-1] == 'C':
imageDict = self.colorPipe_Bayer12(imageArray)
elif self.sensorInfo.strSensorName.decode('utf8')[-1] == 'M':
imageDict = self.colorPipe_Mono(imageArray)
elif self.sensorInfo.strSensorName.decode(
'utf8')[-1] != 'C' and self.sensorInfo.strSensorName.decode(
'utf8')[-1] != 'M':
raise NameError(
'Sensor type not recognized by the IDSCamera.capture_image function!'
)
return imageDict
