def startVolumeSlider(self):
#open file
self.nChannels, self.nVols, self.slicesPerVolume = load_tiff.gui()
#print(self.nChannels, self.nVols, self.slicesPerVolume)
#copy selected window
self.A = g.win.image
text_1 = 'Volume Slider Window'
if self.nChannels == 2:
self.B = load_tiff.channel_1.imageview.getProcessedImage()
text_1 = 'Volume Slider Channel 2'
text_2 = 'Volume Slider Channel 1'
#initiate image
self.initiateImage()
#display image
self.displayWindow = Window(self.displayImage[self.displayedTimeSlice:(self.displayedTimeSlice+self.numberOfTimeSlices)],text_1)
if self.nChannels == 2:
self.displayWindow_2 = Window(self.displayImage_2[self.displayedTimeSlice:(self.displayedTimeSlice+self.numberOfTimeSlices)],text_2)
#open gui
self.dialogbox = Form3()
self.dialogbox.show()
#link 2 channel display window time sliders
if self.nChannels == 2:
self.displayWindow.imageview.timeLine.sigPositionChanged.connect(self.updateFrameSlider)
self.displayWindow_2.imageview.timeLine.sigPositionChanged.connect(self.updateFrameSlider_2)
return
def crop(self):
"""Create a new window of the image cropped to this ROI
Returns:
window.Window: cropped image Window
"""
from flika.window import Window
r = self.boundingRect()
p1 = r.topLeft() + self.state['pos']
p2 = r.bottomRight() + self.state['pos']
x1, y1 = int(p1.x()), int(p1.y())
x2, y2 = int(p2.x()), int(p2.y())
if x1 < 0: x1 = 0
if y1 < 0: y1 = 0
tif = self.window.image
#if self.window.imageview.hasTimeAxis():
if self.window.mt > 1:
mt, mx, my = tif.shape[:3]
if x2 >= mx: x2 = mx - 1
if y2 >= my: y2 = my - 1
newtif = tif[:, x1:x2, y1:y2]
else:
mx, my = tif.shape[:2]
if x2 >= mx: x2 = mx - 1
if y2 >= my: y2 = my - 1
newtif = tif[x1:x2, y1:y2]
w = Window(newtif,
self.window.name + ' Cropped',
metadata=self.window.metadata)
w.imageview.setImage(newtif, axes=self.window.imageview.axes)
w.image = newtif
return w
def __call__(self, nSteps, shift_factor, theta, triangle_scan, interpolate, trim_last_frame, zscan, keepSourceWindow=False):
g.settings['light_sheet_analyzer']['nSteps']=nSteps
g.settings['light_sheet_analyzer']['shift_factor']=shift_factor
g.settings['light_sheet_analyzer']['theta']=theta
g.settings['light_sheet_analyzer']['triangle_scan'] = triangle_scan
g.settings['light_sheet_analyzer']['interpolate'] = interpolate
g.settings['light_sheet_analyzer']['trim_last_frame'] = trim_last_frame
g.settings['light_sheet_analyzer']['zscan'] = zscan
g.m.statusBar().showMessage("Generating 4D movie ...")
t = time()
self.start(keepSourceWindow)
A = np.copy(self.tif)
if zscan:
A = A.swapaxes(1,2)
mt, mx, my = A.shape
if triangle_scan:
for i in np.arange(mt // (nSteps * 2)):
t0 = i * nSteps * 2 + nSteps
tf = (i + 1) * nSteps * 2
A[t0:tf] = A[tf:t0:-1]
mv = mt // nSteps # number of volumes
A = A[:mv * nSteps]
B = np.reshape(A, (mv, nSteps, mx, my))
if trim_last_frame:
B = B[:, :-1, :, :]
#D = perform_shear_transform_old(B, shift_factor, interpolate, A.dtype)
D = perform_shear_transform(B, shift_factor, interpolate, A.dtype, theta)
g.m.statusBar().showMessage("Successfully generated movie ({} s)".format(time() - t))
w = Window(np.squeeze(D[:, 0, :, :]), name=self.oldname)
w.volume = D
Volume_Viewer(w)
return
def convertFileToTiff(self):
if self.fileType == 'avi':
cap = cv2.VideoCapture(self.currentFile)
while (cap.isOpened()):
try:
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
cv2.imshow('frame', gray)
self.recordingList.append(self.convertImage(gray))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
except:
break
cap.release()
cv2.destroyAllWindows()
recordingArray = np.array(self.recordingList)
self.displayWindow = Window(recordingArray, 'Image Window')
self.recordingList = []
else:
img = cv2.imread(self.currentFile)
self.displayWindow = Window(img, 'Image Window')
self.flipImageLR()
self.rotateImageClock()
return
def startVolumeSlider(self, A=[], keepWindow=False, batch=False):
if batch:
self.batch = True
self.batchOptions = BatchOptions()
self.batchOptions.start()
return
if A == []:
#copy selected window
self.A = np.array(deepcopy(g.win.image), dtype=self.dataType)
if keepWindow == False:
g.win.close()
else:
#load numpy array
self.B = A
self.nFrames, self.nVols, self.x, self.y = self.B.shape
self.dialogbox = Form2(camVolumeSlider)
self.viewer = SliceViewer(camVolumeSlider, self.B)
return
self.B = []
#get shape
self.nFrames, self.x, self.y = self.A.shape
self.framesPerVol = int(self.nFrames / self.nVols)
#setup display window
self.displayWindow = Window(self.A, 'Volume Slider Window')
#open gui
self.dialogbox = Form2(camVolumeSlider)
self.dialogbox.show()
return
def startVolumeSlider(self,
A=[],
keepWindow=False,
batch=False,
preProcess=False,
nVols=None,
framesPerVol=None,
framesToDelete=0,
overlayEmbeded=False,
A_overlay=None):
self.overlayEmbeded = overlayEmbeded
if batch:
self.batch = True
self.batchOptions = BatchOptions()
self.batchOptions.start()
return
if A == []:
#copy selected window
self.A = np.array(deepcopy(g.win.image), dtype=self.dataType)
if keepWindow == False:
g.win.close()
else:
#load numpy array
self.B = A
self.nFrames, self.nVols, self.x, self.y = self.B.shape
self.dialogbox = Form2(camVolumeSlider)
self.viewer = SliceViewer(camVolumeSlider, self.B)
return
self.B = []
#get shape
self.nFrames, self.x, self.y = self.A.shape
self.framesPerVol = int(self.nFrames / self.nVols)
#setup display window
self.displayWindow = Window(self.A, 'Volume Slider Window')
#open gui
self.dialogbox = Form2(camVolumeSlider)
self.dialogbox.show()
if preProcess:
self.preProcess_stack(framesPerVol, framesToDelete=0)
if overlayEmbeded:
print('Generating overlay window...')
self.A_overlay = A_overlay
self.overlayWindow = Window(self.A_overlay, 'Overlay Window')
self.processOverlay(framesPerVol, framesToDelete=0)
#start 3D display
self.startViewer()
return
def startVolumeSlider(self, volume_path):
self.volume_path = volume_path
#get volume arrays
self.getVolumes()
#update image
self.initiateImage()
#display image
self.displayWindow = Window(self.displayImage[self.displayedTimeSlice:(self.displayedTimeSlice+self.numberOfTimeSlices)],'Volume Slider Window')
#open gui
self.dialogbox = Form()
self.dialogbox.show()
return
def showMask(self):
"""Create a new binary window that visualizes the ROI mask
Returns:
window.Window: created mask window
"""
from flika.window import Window
self.copy()
im = np.zeros_like(self.window.imageview.getImageItem().image)
s1, s2 = self.getMask()
im[s1, s2] = 1
w = Window(im)
w.paste()
return w
def addIndex(self):
#get data
A = deepcopy(self.getValue('window').image)
A_labelled = np.zeros_like(A)
font = ImageFont.truetype(r'C:/Windows/Fonts/Arial/arial.ttf', self.getValue('fontSize'))
colour = self.fontColour_combobox.currentText()
position = self.textPosition_combobox.currentText()
#print(colour,position)
#add index
for i in range(len(A)):
img = Image.fromarray(A[i])
img = img.rotate(90, Image.NEAREST, expand = 1)
img = ImageOps.flip(img)
img_editable = ImageDraw.Draw(img)
img_editable.text((2, 2), str(i), fill=colour, anchor=position, font=font)
img = ImageOps.flip(img)
img = img.rotate(-90, Image.NEAREST, expand = 1)
A_labelled[i] = np.array(img)
#display stack in new window
self.indexed_win = Window(A_labelled,'Indexed')
return
def create_binary_window(self):
true_rois = self.window_states == 1
bin_im = np.zeros_like(self.image, dtype=np.uint8)
for i in np.nonzero(true_rois)[0]:
x, y = self.window_props[i].coords.T
bin_im[x, y] = 1
Window(bin_im, 'Binary')
def startVolumeSlider(self):
#open file
self.nChannels, self.nVols, self.slicesPerVolume, self.A, self.B = load_tiff.gui(
)
print(self.nChannels, self.nVols, self.slicesPerVolume)
self.C = []
self.D = []
#copy selected window
#self.A = g.win.image
#self.A = self.channel1_array
#get shape
self.nFrames, self.x, self.y = self.A.shape
self.framesPerVol = int(self.nFrames / self.nVols)
text_1 = 'Volume Slider Window'
if self.nChannels == 2:
#self.B = self.channel2_array
text_1 = 'Volume Slider Channel 2'
text_2 = 'Volume Slider Channel 1'
#Reshape original array(s) for display
self.C = np.reshape(self.A,
(self.slicesPerVolume, self.nVols, self.x, self.y),
order='F')
if self.nChannels == 2:
self.D = np.reshape(
self.B, (self.slicesPerVolume, self.nVols, self.x, self.y),
order='F')
#display image
self.displayWindow = Window(self.C[0], text_1)
if self.nChannels == 2:
self.displayWindow_2 = Window(self.D[0], text_2)
#open gui
self.dialogbox = Form3()
self.dialogbox.show()
#link 2 channel display window time sliders
if self.nChannels == 2:
self.displayWindow.imageview.timeLine.sigPositionChanged.connect(
self.updateFrameSlider)
self.displayWindow_2.imageview.timeLine.sigPositionChanged.connect(
self.updateFrameSlider_2)
return
def start(self):
self.clock = Clock()
self.initializeFolderCheck()
#start display window(s)
#single-channel
self.displayWindow_1 = Window(self.initializeArray, 'Channel 1')
#self.volumeArrayWindow_1 = Window(self.initializeArray ,'Channel 1 for v-Viewer')
#2-channel
if self.nChannels == 2:
self.displayWindow_2 = Window(self.initializeArray, 'Channel 2')
#initialize FLAG settings
self.displayWindow_FLAG = True
self.autolevelsFlag_1 = True
self.autolevelsFlag_2 = True
return
def createKymograph(self, mn):
from flika.window import Window
oldwindow = g.win
name = oldwindow.name + ' - Kymograph'
self.kymograph = Window(mn, name, metadata=self.window.metadata)
self.sigRegionChanged.connect(self.update_kymograph)
self.kymograph.closeSignal.connect(self.deleteKymograph)
self.sigRemoveRequested.connect(self.deleteKymograph)
def preview(self):
im = self.getArrayRegion(self.window.imageview.getImageItem().image,
self.window.imageview.getImageItem(), (0, 1))
if not hasattr(self, 'prev'):
from flika.window import Window
self.prev = Window(im)
self.sigRegionChanged.connect(lambda a: self.preview())
else:
self.prev.imageview.setImage(im)
def exportToWindow(self):
if self.B == []:
print('first set number of frames per volume')
g.m.statusBar().showMessage(
"first set number of frames per volume")
else:
Window(
np.reshape(self.B, (self.nFrames, self.x, self.y), order='F'))
return
def createKymograph(self, mn):
from flika.window import Window
oldwindow = g.win
name = oldwindow.name + ' - Kymograph'
self.kymograph = Window(mn, name, metadata=self.window.metadata)
self.kymographproxy = pg.SignalProxy(
self.sigRegionChanged, rateLimit=1,
slot=self.update_kymograph) #This will only update 3 Hz
self.sigRegionChanged.connect(self.update_kymograph)
self.kymograph.closeSignal.connect(self.deleteKymograph)
def preview(self):
winRed = self.getValue('red_window')
winGreen = self.getValue('green_window')
x_shift = self.getValue('x_shift')
y_shift = self.getValue('y_shift')
if not winRed or not winGreen:
if hasattr(self, "window"):
self.window.hide()
return
if self.current_red != winRed:
self.unlink_frames(self.current_red)
winRed.sigTimeChanged.connect(self.indexChanged)
self.current_red = winRed
if self.current_green != winGreen:
self.unlink_frames(self.current_green)
winGreen.sigTimeChanged.connect(self.indexChanged)
self.current_green = winGreen
imG = winGreen.image
imR = winRed.image
if imR.ndim == 3:
imR = imR[winRed.currentIndex]
if imG.ndim == 3:
imG = imG[winGreen.currentIndex]
if np.size(imR) < np.size(imG):
imG, imR = imR, imG
imG = self.pad_shift(imG, imR, x_shift, y_shift)
self.minlevel = np.min([np.min(imG), np.min(imR)])
self.maxlevel = np.max([np.max(imG), np.max(imR)])
imZ = np.zeros_like(imR)
stacked = np.dstack((imR, imG, imZ))
if not hasattr(self, 'window') or self.window.closed:
self.window = Window(stacked, name="Beam Splitter Overlay Frame")
self.window.imageview.setLevels(self.minlevel, self.maxlevel)
self.window.imageview.keyPressEvent = self.keyPressed
else:
self.window.imageview.setImage(stacked, autoLevels=False, autoRange=False)
self.window.show()
def make_maxintensity(self):
vol = self.window.volume
new_vol = np.max(vol, 1)
if self.currentAxisOrder[1] == 1: # 'z'
name = 'Max Z projection'
elif self.currentAxisOrder[1] == 2: # 'x'
name = 'Max X projection'
elif self.currentAxisOrder[1] == 3: # 'y'
name = 'Max Y projection'
Window(new_vol, name=name)
def startVolumeSlider(self):
#copy selected window
self.A = g.win.image
#update image
self.initiateImage()
#display image
self.displayWindow = Window(self.displayImage[self.displayedTimeSlice:(self.displayedTimeSlice+self.numberOfTimeSlices)],'Volume Slider Window')
#open gui
self.dialogbox = Form2()
self.dialogbox.show()
return
def step1(self):
#save path
savePath = self.getValue('resultsFolder1')
#get dipole data
dipole = self.getValue('dipoleWindow')
dipole.setWindowTitle('dipole')
#gaussian blur
gaussianBlurred = gaussian(dipole.imageview.getProcessedImage(),
self.getValue('step1GuassianValue'))
if self.getValue('step1Gaussian'):
Window(gaussianBlurred, 'dipole - gaussian blurred')
#threshold
dipole_thresh = gaussianBlurred > self.getValue('step1ThresholdValue')
dipole_thresh = dipole_thresh.astype(int)
if self.getValue('step1Threshold'):
Window(dipole_thresh, 'dipole - thresholded')
#get superResData
superRes = self.getValue('twoColorWindow')
superRes.setWindowTitle('twoColorSuperRes')
#overlay
#overlay = background(dipole_thresh,superRes,0.5, True)
#mask by threshold
superRes_crop = superRes.imageview.getProcessedImage()
mask = dipole_thresh < 1
superRes_crop[mask] = [0, 0, 0]
#create window
Window(superRes_crop, 'twoColor_Crop')
#save image
save_file(os.path.join(savePath, 'twoColor_crop.tif'))
return
def removeFlash_noiseScaling(self):
#print('Not implemented')
#return
img = deepcopy(self.getValue('window').image)
if self.getValue('manualFlash'):
#manual
flashStart = self.getValue('flashStart')
flashEnd = self.getValue('flashEnd')
else:
#autodetect
flashStart, flashEnd = self.autodetectFlash()
#buffer flash time ends
flashStart = flashStart - 1
flashEnd = flashEnd + 2
flash = img[flashStart:flashEnd]
#TODO
#get baseline from 100 frames before flash
baseline = np.mean(img[flashStart - 102:flashStart - 2], axis=0)
#self.baseline_win = Window(baseline,'baseline')
#determine noise of baseline
baseNoise = np.std(img[flashStart - 102:flashStart - 2])
print('baseNoise: ', baseNoise)
#get mean inital flash increase
flashIncrease = np.mean(flash[2:12], axis=0) - baseline
#self.flashIncrease_win = Window(flashIncrease,'flashIncrease')
#get noise of flash
flashNoise = np.std(flash[2:12])
print('flashNoise: ', flashNoise)
#flashNoise:baseNoise ratio
noiseRatio = flashNoise / baseNoise
#subtract flashIncrease from img
#flashReplace = flash - flashIncrease
#self.flashReplace_win = Window(flashReplace,'flashReplace')
#scaled reduction of flash
flashReplace = np.divide(img[flashStart + 1:flashEnd - 1], noiseRatio)
#self.flashReplace_win = Window(flashReplace,'flashReplace')
img[flashStart + 1:flashEnd - 1] = flashReplace
#display stack in new window
self.flashRemoved_win = Window(img, 'Flash Removed (noise scaling)')
return
def startVolumeSlider(self):
#get volume arrays
self.getVolumes()
#display 1st volume
self.displayWindow = Window(self.A_list[0],'Volume Slider Window')
self.displayedVol = 0
self.maxFrames, self.width, self.height = self.A_list[0].shape
#open gui
self.dialogbox = Form()
self.dialogbox.show()
#connect window time slider to volumeSlider GUI
self.displayWindow.imageview.timeLine.sigPositionChanged.connect(self.updateFrameSlider)
return
def overlay(self):
red = self.displayImage
green = self.displayImage_2
self.overlayed = np.zeros((red.shape[0], red.shape[1], red.shape[2], 3))
self.overlayed[:,:,:,0] = red
self.overlayed[:,:,:,1] = green
#print(self.overlayed.shape)
self.displayWindow_Overlay = Window(self.overlayed[self.displayedTimeSlice:(self.displayedTimeSlice+self.numberOfTimeSlices)],'Overlay')
self.overlayFlag = True
return
def removeFlash_interpolate(self):
img = deepcopy(self.getValue('window').image)
if self.getValue('manualFlash'):
#manual
flashStart = self.getValue('flashStart')
flashEnd = self.getValue('flashEnd')
else:
#autodetect
flashStart, flashEnd = self.autodetectFlash()
#buffer flash time ends
flashStart = flashStart - 1
flashEnd = flashEnd + 2
flash = img[flashStart:flashEnd]
n, r, c = flash.shape
flashReplace = np.zeros_like(flash)
# update each pixel in image with interpolated values
for row in range(r):
for col in range(c):
points = range(0, n)
xp = [0, n]
fp = [flash[0, row, col], flash[-1, row, col]]
interp_data = np.interp(points, xp, fp)
flashReplace[0:n, row, col] = interp_data
#add noise
if self.getValue('addNoise'):
flashLength = flashEnd - flashStart
if flashStart - flashLength < 0:
print('Not enough trace to sample before flash to get noise')
noise = np.zeros_like(flash)
else:
noise = self.generateNoise(flashStart - flashLength,
flashStart)
else:
noise = np.zeros_like(flash)
img[flashStart:flashEnd] = (flashReplace +
(noise - np.mean(noise, axis=0)))
#display stack in new window
self.flashRemoved_win = Window(img,
'Flash Removed (linear interpolation)')
return
def startVolumeViewer(self):
A = np.copy(self.recordingArray_1)
if self.zscan:
A = A.swapaxes(1, 2)
mt, mx, my = A.shape
if self.triangle_scan:
for i in np.arange(mt // (self.nSteps * 2)):
t0 = i * self.nSteps * 2 + self.nSteps
tf = (i + 1) * self.nSteps * 2
A[t0:tf] = A[tf:t0:-1]
mv = mt // self.nSteps # number of volumes
A = A[:mv * self.nSteps]
B = np.reshape(A, (mv, self.nSteps, mx, my))
A_dataType = A.dtype
A = np.zeros((2, 2)) #clear array to save memory
if self.trim_last_frame:
B = B[:, :-1, :, :]
D = perform_shear_transform(B, self.shift_factor, self.interpolate,
A_dataType, self.theta)
B = np.zeros((2, 2)) #clear array to save memory
w = Window(np.squeeze(D[:, 0, :, :]), name='Volume View')
w.volume = D
D = np.zeros((2, 2)) #clear array to save memory
self.volumeViewer = Volume_Viewer(w)
return
def removeFrames(self):
img = deepcopy(self.getValue('window').image)
start = np.arange(self.getValue('start'), self.getValue('end'),
self.getValue('interval'))
toDelete = []
for i in start:
toDelete.extend(np.arange(i, i + self.getValue('length')))
img = np.delete(img, toDelete, 0)
#display stack in new window
self.framesRemoved_win = Window(img, 'Frames Removed')
return
def getRecording(self):
recordingArray = np.array(self.recordingList)
# Time elapsed
seconds = self.endRecordingTime - self.startRecordingTime
# Estimate frames per second
fps = len(self.recordingList) / seconds
# Add recording to new window
message = 'Recording (duration: ' + str(round(
seconds, 2)) + ' s, fps: ' + str(round(fps, 2)) + ')'
Window(recordingArray, message)
self.recordingList = []
return
def overlay(self):
red = self.displayWindow.imageview.getProcessedImage()
green = self.displayWindow_2.imageview.getProcessedImage()
self.overlayed = np.zeros(
(red.shape[0], red.shape[1], red.shape[2], 3))
self.overlayed[:, :, :, 0] = red
self.overlayed[:, :, :, 1] = green
#print(self.overlayed.shape)
if self.overlayFlag == False:
self.displayWindow_Overlay = Window(self.overlayed[0], 'Overlay')
self.overlayFlag = True
else:
self.displayWindow_Overlay.imageview.setImage(self.overlayed[0],
autoLevels=False)
return
def overlay(self):
red = self.getValue('red_window').image
green = self.getValue('green_window').image
checked = self.getValue('scaleImages')
self.overlayed = np.zeros((red.shape[0], red.shape[1], red.shape[2], 3))
if checked == True:
if np.max(red) > np.max(green):
green = green * int((np.max(red)/np.max(green)))
else:
red = red * int((np.max(green)/np.max(red)))
self.overlayed[:,:,:,0] = red
self.overlayed[:,:,:,1] = green
#print(np.max(red),np.max(green))
self.displayWindow_Overlay = Window(self.overlayed,'Overlay')
return
def setOverlay(self):
if self.B == []:
print('first set number of frames per volume')
g.m.statusBar().showMessage(
"first set number of frames per volume")
self.overlayVolume = self.displayWindow.imageview.currentIndex
print("Setting overlay from currrent volume: " +
str(self.overlayVolume))
#create overlay
self.A_overlay = self.B[:, self.overlayVolume, :, :]
self.overlayWindow = Window(self.A_overlay[0], 'Overlay Window')
self.overlayEmbeded = True
#update main display
self.B = self.B[:, 0:self.overlayVolume, :, :]
self.displayWindow.imageview.setImage(self.B[0], autoLevels=False)
self.displayWindow.imageview.setCurrentIndex(self.overlayVolume - 1)
return
