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