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