def info(self):
print('======================= Camera info ==========================')
if self.sensorInfo.strSensorName.decode('utf8')[-1] == 'C':
print('COLOR sensor detected.')
elif self.sensorInfo.strSensorName.decode('utf8')[-1] == 'M':
print('MONOCHROMATIC sensor detected.')
elif self.sensorInfo.strSensorName.decode(
'utf8')[-1] != 'C' and self.sensorInfo.strSensorName.decode(
'utf8')[-1] != 'M':
print(
'WARNING: Unknown sensor type (mono/RGB). Image capturing will not work correctly.'
)
print('--------------------------------------------------------------')
#print('Current maximal acquisition speed: ' + str(self.currentFPS) + ' fps')
expTimeMin = ueye.c_double(0)
expTimeMax = ueye.c_double(1000)
ueye.is_Exposure(self.CamID,
ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN,
expTimeMin, ueye.sizeof(expTimeMin))
ueye.is_Exposure(self.CamID,
ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
expTimeMax, ueye.sizeof(expTimeMax))
print('Exposure time range: ' +
str(round(expTimeMin.value * 1000, 3)) + ' to ' +
str(round(expTimeMax.value * 1000, 3)) + ' us')
print('--------------------------------------------------------------')
for i in self.sensorInfo._fields_:
print(str(i[0]) + ": " + str(eval('self.sensorInfo.%s' % i[0])))
def set_fps(self, fps):
"""
Set the fps.
Returns
=======
fps: number
Real fps, can be slightly different than the asked one.
"""
# checking available fps
mini, maxi = self.get_fps_range()
if fps < mini:
print(f'Warning: Specified fps ({fps:.2f}) not in possible range:'
f' [{mini:.2f}, {maxi:.2f}].'
f' fps has been set to {mini:.2f}.')
fps = mini
if fps > maxi:
print(f'Warning: Specified fps ({fps:.2f}) not in possible range:'
f' [{mini:.2f}, {maxi:.2f}].'
f' fps has been set to {maxi:.2f}.')
fps = maxi
fps = ueye.c_double(fps)
new_fps = ueye.c_double()
check(ueye.is_SetFrameRate(self.h_cam, fps, new_fps))
self.current_fps = float(new_fps)
return new_fps
def setExposure(self, ms):
ms_old = ueye.c_double(0)
rv = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, ms_old, ueye.sizeof(ms_old))
ems = ueye.c_double(ms)
rv = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, ems, ueye.sizeof(ems))
ms_old = ueye.c_double(0)
rv = ueye.is_Exposure(self.hCam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, ms_old, ueye.sizeof(ms_old))
return rv
def set_intTime(self, intTime):
intTime = intTime / 1000
""" Set the exposure time in microseconds. """
expTime = ueye.c_double(intTime)
ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
expTime, ueye.sizeof(expTime))
wert = ueye.c_double()
sizeo = ueye.sizeof(wert)
ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, wert,
sizeo)
def get_fps_range(self):
"""
Get the current fps available range.
Returns
=======
fps_range: 2x1 array
range of available fps
"""
mini = ueye.c_double()
maxi = ueye.c_double()
interv = ueye.c_double()
check(ueye.is_GetFrameTimeRange(self.h_cam, mini, maxi, interv))
return [float(1 / maxi), float(1 / mini)]
def set_gain_auto(self, toggle):
"""
Set/unset auto gain.
Params
======
toggle: integer
1 activate the auto gain, 0 deactivate it
"""
value = ueye.c_double(toggle)
value_to_return = ueye.c_double()
check(
ueye.is_SetAutoParameter(self.h_cam, ueye.IS_SET_ENABLE_AUTO_GAIN,
value, value_to_return))
def set_exposure_auto(self, toggle):
"""
Set auto expose to on/off.
Params
=======
toggle: integer
1 activate the auto gain, 0 deactivate it
"""
value = ueye.c_double(toggle)
value_to_return = ueye.c_double()
check(
ueye.is_SetAutoParameter(self.h_cam,
ueye.IS_SET_ENABLE_AUTO_SHUTTER, value,
value_to_return))
def getExposureTime(self):
self.exposureTime=ueye.c_double()
if ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, self.exposureTime, ueye.sizeof(ueye.c_double)):
self.status=True
_logger.error("Error retrinving Exposure time")
return True
return False
def getExposureRange(self):
ExposureRange=[ueye.c_double() for i in range(3)]
self.ExposureRange=(ueye.c_double*3)(*ExposureRange)
if ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE, self.ExposureRange, ueye.sizeof(self.ExposureRange)):
_logger.error("Error retrinving exposure range")
self.status=True
return True
def set_gain_auto(self, toggle):
"""
Set/unset auto gain.
Params
======
toggle: integer
1 activate the auto gain, 0 deactivate it
"""
value = ueye.c_double(toggle)
value_to_return = ueye.c_double()
self.nRet = ueye.is_SetAutoParameter(self.cam,
ueye.IS_SET_ENABLE_AUTO_GAIN,
value,
value_to_return)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_SetAutoParameter")
def get_fps_range(self):
"""
Get the current fps available range.
Returns
=======
fps_range: 2x1 array
range of available fps
"""
mini = ueye.c_double()
maxi = ueye.c_double()
interv = ueye.c_double()
self.nRet = ueye.is_GetFrameTimeRange(
self.cam,
mini, maxi, interv)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_GetFrameTimeRange")
return [float(1/maxi), float(1/mini)]
def get_temperature(self):
temp = ueye.c_double()
nRet = ueye.is_DeviceFeature(
self.CamID, ueye.IS_DEVICE_FEATURE_CMD_GET_TEMPERATURE, temp,
ueye.sizeof(temp))
if nRet == 0:
return temp
else:
raise RuntimeError('Temperature readout failed. Error code:' +
self.ueyeMessage(nRet))
def get_framerate(self):
"""
Get frame rate.
Only in free run mode.
"""
new_fps = ueye.c_double(self.current_fps)
self.nRet = ueye.is_GetFramesPerSecond(self.cam, new_fps)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_GetFramesPerSecond")
print(new_fps.value)
def set_fps(self, fps):
"""
Set the fps.
Returns
=======
fps: number
Real fps, can be slightly different than the asked one.
"""
# checking available fps
mini, maxi = self.get_fps_range()
if fps < mini:
fps = mini
if fps > maxi:
fps = maxi
fps = ueye.c_double(fps)
new_fps = ueye.c_double()
check(ueye.is_SetFrameRate(self.h_cam, fps, new_fps))
self.current_fps = float(new_fps)
return new_fps
def setExposureTime(self, value): self.getExposureRange() if (value<self.ExposureRange[0].value) & (value>self.ExposureRange[1].value): self.status=True return True ran=np.arange(self.ExposureRange[0].value, self.ExposureRange[1].value, self.ExposureRange[2].value) nwv=ueye.c_double(ran[np.abs(ran-value).argmin()]) if ueye.is_Exposure(self.hcam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, nwv, ueye.sizeof(nwv)): self.status=True return True return False
def get_exposure(self):
"""
Get the current exposure.
Returns
=======
exposure: number
Current exposure.
"""
exposure = ueye.c_double()
check(ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE,
exposure, 8))
return exposure
def set_exposure(self, exposure):
"""
Set the exposure.
Returns
=======
exposure: number
Real exposure, can be slightly different than the asked one.
"""
new_exposure = ueye.c_double(exposure)
check(
ueye.is_Exposure(self.h_cam, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
new_exposure, 8))
return new_exposure
def get_fps(self):
"""
Get the current fps.
Returns
=======
fps: number
Current fps.
"""
if self.current_fps is not None:
return self.current_fps
fps = ueye.c_double()
check(ueye.is_GetFramesPerSecond(self.h_cam, fps))
return fps
def get_exposure(self):
"""
Get the current exposure.
Returns
=======
exposure: number
Current exposure.
"""
exposure = ueye.c_double()
self.nRet = ueye.is_Exposure(self.cam, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE,
exposure, 8)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_Exposure")
return exposure
def set_exposure(self, exposure):
"""
Set the exposure.
Returns
=======
exposure: number
Real exposure, can be slightly different than the asked one.
"""
exposure = ueye.c_double(exposure)
self.nRet = ueye.is_Exposure(self.cam,
ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
exposure,
8)
if self.nRet != ueye.IS_SUCCESS:
error_log(self.nRet, "is_Exposure")
def connect(self):
""" Connects to the USB camera, creates main controlling object + prints out confirmation """
connectRet = ueye.is_InitCamera(self.CamID, None)
if connectRet == 0: # on succesful connection
self.connected = True
self.sensorInfo = ueye.SENSORINFO()
print('IDS camera connected.')
ueye.is_GetSensorInfo(self.CamID, self.sensorInfo)
self.sensorHeight_ctype, self.sensorWidth_ctype = self.sensorInfo.nMaxHeight, self.sensorInfo.nMaxWidth
self.currentHeight, self.currentWidth = self.sensorHeight_ctype.value, self.sensorWidth_ctype.value
# Settings block
ueye.is_PixelClock(self.CamID, ueye.IS_PIXELCLOCK_CMD_SET,
ueye.c_int(self.pixelClock),
ueye.sizeof(ueye.c_int(self.pixelClock)))
self.currentFPS = ueye.c_double(0)
#ueye.is_SetFrameRate(self.CamID, ueye.c_int(self.FPS),self.currentFPS)
ueye.is_SetDisplayMode(self.CamID, ueye.IS_SET_DM_DIB)
ueye.is_SetColorMode(self.CamID, ueye.IS_CM_SENSOR_RAW12)
ueye.is_SetAutoParameter(self.CamID, ueye.IS_SET_ENABLE_AUTO_GAIN,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_SENSOR_GAIN,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_SHUTTER,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_SENSOR_SHUTTER,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(self.CamID,
ueye.IS_SET_ENABLE_AUTO_WHITEBALANCE,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetAutoParameter(
self.CamID, ueye.IS_SET_ENABLE_AUTO_SENSOR_WHITEBALANCE,
ueye.c_double(0), ueye.c_double(0))
ueye.is_SetHardwareGain(self.CamID, ueye.c_int(0), ueye.c_int(0),
ueye.c_int(0), ueye.c_int(0))
# Show a pattern (for testing)
#ueye.is_SetSensorTestImage(self.CamID,ueye.IS_TEST_IMAGE_HORIZONTAL_GREYSCALE, ueye.c_int(0))
else:
print('Camera connecting failure...')
def get_intTime(self):
wert = ueye.c_double()
sizeo = ueye.sizeof(wert)
ueye.is_Exposure(self.CamID, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, wert,
sizeo)
return wert.value * 1000
def configure_device(self):
self.nRet = ueye.is_ResetToDefault(self.hid)
if self.nRet != ueye.IS_SUCCESS:
print('Reset ERROR')
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN,
self.minExp, 8)
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
self.maxExp, 8)
self.nRet = ueye.is_SetDisplayMode(self.hid, ueye.IS_SET_DM_DIB)
if self.nRet != ueye.IS_SUCCESS:
print('Display Mode ERROR')
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE,
ueye.c_double(1), 8)
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_GET_EXPOSURE, self.Exp,
8)
# Set the right color mode
if int.from_bytes(self.sinfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_BAYER:
# setup the color depth to the current windows setting
ueye.is_GetColorDepth(self.hid, self.bitspixel, self.colorm)
self.bytesppixel = int(self.bitspixel / 8)
elif int.from_bytes(self.sinfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_CBYCRY:
# for color camera models use RGB32 mode
self.colorm = ueye.IS_CM_BGRA8_PACKED
self.bitspixel = ueye.INT(32)
self.bytesppixel = int(self.bitspixel / 8)
elif int.from_bytes(self.sinfo.nColorMode.value,
byteorder='big') == ueye.IS_COLORMODE_MONOCHROME:
# for color camera models use RGB32 mode
self.colorm = ueye.IS_CM_MONO8
self.bitspixel = ueye.INT(8)
self.bytesppixel = int(self.bitspixel / 8)
else:
# for monochrome camera models use Y8 mode
self.colorm = ueye.IS_CM_MONO8
self.bitspixel = ueye.INT(8)
self.bytesppixel = int(self.bitspixel / 8)
self.nRet = ueye.is_AOI(self.hid, ueye.IS_AOI_IMAGE_GET_AOI, self.rect,
ueye.sizeof(self.rect))
self.width = self.rect.s32Width
self.height = self.rect.s32Height
if self.nRet != ueye.IS_SUCCESS:
print('AOI ERROR')
self.nRet = ueye.is_AllocImageMem(self.hid, self.width, self.height,
self.bitspixel, self.ppcImgMem,
self.MemID)
if self.nRet != ueye.IS_SUCCESS:
print('AllocImageMem ERROR')
else:
self.nRet = ueye.is_SetImageMem(self.hid, self.ppcImgMem,
self.MemID)
if self.nRet != ueye.IS_SUCCESS:
print('SetImageMem ERROR')
else:
self.nRet = ueye.is_SetColorMode(self.hid, self.colorm)
self.nRet = ueye.is_CaptureVideo(self.hid, ueye.IS_DONT_WAIT)
if self.nRet != ueye.IS_SUCCESS:
print('CaptureVideo ERROR')
self.nRet = ueye.is_InquireImageMem(self.hid, self.ppcImgMem,
self.MemID, self.width,
self.height, self.bitspixel,
self.pitch)
if self.nRet != ueye.IS_SUCCESS:
print('InquireImageMem ERROR')
for i in range(10):
self.measure()
self.disconnect_device()
from pyueye import ueye
hcam = ueye.HIDS(0)
pccmem = ueye.c_mem_p()
memID = ueye.c_int(0)
ueye.is_InitCamera(hcam, None)
sensorinfo = ueye.SENSORINFO()
ueye.is_GetSensorInfo(hcam, sensorinfo)
ueye.is_SetColorMode(hcam, ueye.IS_CM_SENSOR_RAW8)
ueye.is_AllocImageMem(hcam, sensorinfo.nMaxWidth, sensorinfo.nMaxHeight, 8,
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
def setFPS(self, fps):
ms_new = ueye.c_double(fps)
new = ueye.c_double(0)
rv = ueye.is_SetFrameRate(self.hCam, ms_new, new)
return new
def setFPS(fps, hCam=0):
ms_new = ueye.c_double(fps)
new = ueye.c_double(0)
rv = ueye.is_SetFrameRate(hCam, ms_new, new)
return new
def __init__(self):
super().__init__()
self.setupUi(self)
##############################################################################
# Button connection ###################################################
self.Movie_Button.clicked.connect(self.Movie)
self.Contrast_Button.clicked.connect(self.Contrast_Enhancement)
self.Diff_Button.clicked.connect(self.Differential_Image)
self.SetBG_Button.clicked.connect(self.Set_Background)
self.SetFPS_Button.clicked.connect(self.Set_FPS)
self.SetExp_Button.clicked.connect(self.Set_Exp)
self.SetCurr_Button.clicked.connect(self.Set_Curr)
self.Save_Button.clicked.connect(self.Save)
self.Rec_Button.clicked.connect(self.Rec)
self.Exit_Button.clicked.connect(self.Exit)
# Initial switch setting ##############################################
self.Movie_Switch = -1
self.Contrast_Switch = -1
self.Diff_Switch = -1
self.SetBG_Switch = -1
self.KepcoInit_Switch = -1
self.Rec_Switch = -1
self.time_avg = 1
self.Img_Sum = 100
# Indicator ###########################################################
if self.Movie_Switch == 1:
self.Movie_Text_Browser.setText("On")
self.Movie_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
elif self.Movie_Switch == -1:
self.Movie_Text_Browser.setText("Off")
self.Movie_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
if self.Contrast_Switch == 1:
self.Contrast_Text_Browser.setPlainText("On")
self.Contrast_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
elif self.Contrast_Switch == -1:
self.Contrast_Text_Browser.setPlainText("Off")
self.Contrast_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
if self.Diff_Switch == 1:
self.Diff_Text_Browser.setPlainText("On")
self.Diff_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
elif self.Contrast_Switch == -1:
self.Diff_Text_Browser.setPlainText("Off")
self.Diff_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
if self.Rec_Switch == 1:
self.Rec_Text_Browser.setPlainText("Rec On")
self.Rec_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
elif self.Rec_Switch == -1:
self.Rec_Text_Browser.setPlainText("Rec Off")
self.Rec_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
# Camera Initialization ###############################################
self.Camera_Initialization()
# Set dummy background image (Black image) ############################
self.bg_raw = ueye.get_data(self.mem_ptr,
self.width,
self.height,
self.bitspixel,
self.lineinc,
copy=True)
self.bg = np.reshape(self.bg_raw,
(self.height, self.width, 1)).astype(np.float64)
self.FinalImage = self.bg
self.bg_resize = cv2.resize(self.bg, (0, 0), fx=0.5, fy=0.5)
self.bg_resize = QtGui.QImage(self.bg_resize, self.bg_resize.shape[1],
self.bg_resize.shape[0],
QtGui.QImage.Format_Indexed8)
self.Movie_Frame.setPixmap(QtGui.QPixmap.fromImage(self.bg_resize))
self.value = ueye.c_double(0)
self.value_to_return = ueye.c_double()
self.nRet = ueye.is_SetAutoParameter(self.hcam,
ueye.IS_SET_ENABLE_AUTO_SHUTTER,
self.value, self.value_to_return)
self.value = ueye.c_double(0)
self.value_to_return = ueye.c_double()
#self.nRet = ueye.is_SetAutoParameter(self.hcam, ueye.IS_SET_ENABLE_AUTO_GAIN, self.value, self.value_to_return)
self.SetFPS_lineEdit.setText(str("%.2f" % self.IDS_FPS).zfill(5))
self.SetFPS_lineEdit.setAlignment(QtCore.Qt.AlignRight)
self.SetExp_lineEdit.setText(str("%.2f" % self.IDS_exposure).zfill(5))
self.SetExp_lineEdit.setAlignment(QtCore.Qt.AlignRight)
def set_exposure(self,exposure):
"""
Set exposure parameter.
"""
ueye.is_Exposure(self.hid, ueye.IS_EXPOSURE_CMD_SET_EXPOSURE, ueye.c_double(exposure), 8 )
def Movie(self):
self.Movie_Switch = -1 * self.Movie_Switch
if self.Movie_Switch == 1:
self.Movie_Text_Browser.setText("On")
self.Movie_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
elif self.Movie_Switch == -1:
self.Movie_Text_Browser.setText("Off")
self.Movie_Text_Browser.setAlignment(QtCore.Qt.AlignCenter)
while (self.Movie_Switch == 1):
self.fps = ueye.c_double()
self.nRet = ueye.is_GetFramesPerSecond(self.hcam, self.fps)
self.FPS_Text_Browser.setText(str("%.2f" % self.fps).zfill(5))
self.FPS_Text_Browser.setAlignment(QtCore.Qt.AlignRight)
self.exposure = ueye.c_double()
self.nRet = ueye.is_Exposure(self.hcam,
ueye.IS_EXPOSURE_CMD_GET_EXPOSURE,
self.exposure, 8)
self.Exp_Text_Browser.setText(str("%.2f" % self.exposure).zfill(5))
self.Exp_Text_Browser.setAlignment(QtCore.Qt.AlignRight)
#kk = 0
#while(kk <= self.Img_Sum):
# kk = kk+1
#
# if kk == 1:
# self.img_raw = (ueye.get_data(self.mem_ptr, self.width, self.height, self.bitspixel, self.lineinc, copy=True)).astype(np.float64)
# else:
# self.img_raw0 = (ueye.get_data(self.mem_ptr, self.width, self.height, self.bitspixel, self.lineinc, copy=True)).astype(np.float64)
# self.img_raw = self.img_raw*(kk-1)/kk+self.img_raw0/kk
# del self.img_raw0
#
# time.sleep(1/self.fps)
self.img_raw = ueye.get_data(self.mem_ptr,
self.width,
self.height,
self.bitspixel,
self.lineinc,
copy=True)
if self.Diff_Switch == -1:
self.img = np.reshape(self.img_raw,
(self.height, self.width, 1)).astype(
np.uint16)
elif self.Diff_Switch == 1:
self.img0 = (np.reshape(self.img_raw,
(self.height, self.width, 1))).astype(
np.float64)
self.img = np.round(
(self.img0 - self.bg + 4095) / 2).astype(np.uint16)
if self.Contrast_Switch == 1:
self.img = np.reshape(self.img, (self.height, self.width))
# Contrast stretching
self.pL, self.pH = np.percentile(self.img, (2, 98))
self.img = exposure.rescale_intensity(self.img,
in_range=(self.pL,
self.pH),
out_range=(0, 4095))
# Equalization
#self.img = img_as_ubyte(exposure.equalize_hist(self.img))
# Adaptive Equalization
#self.img = img_as_ubyte(exposure.equalize_adapthist(self.img, clip_limit=0.5))
self.img = np.reshape(self.img, (self.height, self.width, 1))
self.FinalImage = self.img
if self.Rec_Switch == 1:
if 'vid' in locals():
vid = np.append(vid, self.FinalImage, axis=2)
if vid.shape[2] > 10000:
vid = np.delete(vid, 0, axis=2)
self.Time_1 = time.time()
self.Time = np.append(self.Time, self.Time_1 - self.Time_0)
self.Time_0 = self.Time_1
else:
vid = np.zeros([self.height, self.width])
vid = self.FinalImage
self.Time_0 = time.time()
self.Time = 0
if 'vid' in locals() and self.Rec_Switch == -1:
# selecting file path
filePath, _ = QFileDialog.getSaveFileName(
self, "Save Video", "", "avi(*.avi);;All Files(*.*) ")
# if file path is blank return back
if filePath == "":
del vid
del self.Time
#return
else:
self.fps = np.round(1 / np.median(self.Time))
out = cv2.VideoWriter(filePath,
cv2.VideoWriter_fourcc(*'DIVX'),
self.fps, (self.width, self.height),
isColor=False)
for i in range(0, vid.shape[2]):
img = (np.round(vid[:, :, i] / 4095 * 255) - 1).astype(
np.uint8)
out.write(img)
out.release()
del vid
del self.Time
self.img_resize = cv2.resize(self.FinalImage, (0, 0),
fx=0.5,
fy=0.5)
self.img_resize = (self.img_resize / 4095 * 255).astype(np.uint8)
#self.img_resize = QtGui.QImage(self.img_resize, self.img_resize.shape[1], self.img_resize.shape[0], QtGui.QImage.Format_Indexed8)
self.img_resize = QtGui.QImage(self.img_resize,
self.img_resize.shape[1],
self.img_resize.shape[0],
QtGui.QImage.Format_Indexed8)
self.Movie_Frame.setPixmap(QtGui.QPixmap.fromImage(
self.img_resize))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
