def createLabelLayer(self, direct=False): """ Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: # Add the layer to draw the labels, but don't add any labels labelsrc = LazyflowSinkSource( self._labelingSlots.labelOutput, self._labelingSlots.labelInput) labellayer = ColortableLayer(labelsrc, colorTable = self._colorTable16, direct=direct) labellayer.name = "Labels" labellayer.ref_object = None labellayer.contexts.append(QAction("Import...", None, triggered=partial(import_labeling_layer, labellayer, self._labelingSlots, self))) labellayer.shortcutRegistration = ("0", ShortcutManager.ActionInfo( "Labeling", "LabelVisibility", "Show/Hide Labels", labellayer.toggleVisible, self.viewerControlWidget(), labellayer)) return labellayer, labelsrc
def _initPredictionLayers(self, predictionSlot): layers = [] opLane = self.topLevelOperatorView colors = opLane.PmapColors.value names = opLane.LabelNames.value # Use a slicer to provide a separate slot for each channel layer #opSlicer = OpMultiArraySlicer2( parent=opLane.viewed_operator() ) #opSlicer.Input.connect( predictionSlot ) #opSlicer.AxisFlag.setValue('c') if predictionSlot.ready() : from volumina import colortables predictLayer = ColortableLayer(LazyflowSource(predictionSlot), colorTable = colortables.jet(), normalize = 'auto') #predictLayer = AlphaModulatedLayer( predictsrc, # tintColor=QColor(*colors[channel]), # range=(0.0, 1.0), # normalize=(0.0, 1.0) ) predictLayer.opacity = 0.25 predictLayer.visible = True predictLayer.name = "Prediction" layers.append(predictLayer) return layers
def setupLayers(self): """The LayerViewer base class calls this function to obtain the list of layers that should be displaye in the central viewer. """ layers = [] inputGrid = LazyflowSource(self.topLevelOperatorView.GridOutput) colortable = [QColor(0, 0, 0, 0).rgba(), QColor(255, 0, 0).rgba(),] gridlayer = ColortableLayer(inputGrid, colortable) gridlayer.name = "Grid" gridlayer.zeroIsTransparent = True layers.insert(0, gridlayer) # Show the raw input data as a convenience for the user inputImageSlot = self.topLevelOperatorView.RawInput if inputImageSlot.ready(): inputLayer = self.createStandardLayerFromSlot(inputImageSlot) inputLayer.name = "Raw Input" inputLayer.visible = True inputLayer.opacity = 1.0 layers.append(inputLayer) return layers
def setupLayers(self): layers = [] predictionSlot = self.topLevelOperatorView.PredictionImage if predictionSlot.ready(): predictlayer = ColortableLayer( LazyflowSource(predictionSlot), colorTable=self._colorTable16 ) predictlayer.name = "Prediction" predictlayer.visible = True layers.append(predictlayer) rawSlot = self.topLevelOperatorView.RawImage if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw data" layers.append(rawLayer) binarySlot = self.topLevelOperatorView.BinaryImage if binarySlot.ready(): ct_binary = [QColor(0, 0, 0, 0).rgba(), QColor(255, 255, 255, 255).rgba()] binaryLayer = ColortableLayer(LazyflowSource(binarySlot), ct_binary) binaryLayer.name = "Binary Image" layers.append(binaryLayer) return layers
def createLabelLayer(self, direct=False): """ Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: # Add the layer to draw the labels, but don't add any labels labelsrc = LazyflowSinkSource(self._labelingSlots.labelOutput, self._labelingSlots.labelInput) labellayer = ColortableLayer(labelsrc, colorTable=self._colorTable16, direct=direct) labellayer.name = "Labels" labellayer.ref_object = None labellayer.contexts.append( QAction("Import...", None, triggered=partial(import_labeling_layer, labellayer, self._labelingSlots, self))) labellayer.shortcutRegistration = ("0", ShortcutManager.ActionInfo( "Labeling", "LabelVisibility", "Show/Hide Labels", labellayer.toggleVisible, self.viewerControlWidget(), labellayer)) return labellayer, labelsrc
def createLabelLayer(self, direct=False): """ Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: # Add the layer to draw the labels, but don't add any labels labelsrc = LazyflowSinkSource(self._labelingSlots.labelOutput, self._labelingSlots.labelInput) labellayer = ColortableLayer(labelsrc, colorTable=self._colorTable16, direct=direct) labellayer.name = "Labels" labellayer.ref_object = None labellayer.contexts.append( ("Import...", partial(import_labeling_layer, labellayer, self._labelingSlots, self))) return labellayer, labelsrc
def setupLayers(self): """The LayerViewer base class calls this function to obtain the list of layers that should be displaye in the central viewer. """ layers = [] inputGrid = LazyflowSource(self.topLevelOperatorView.GridOutput) colortable = [ QColor(0, 0, 0, 0).rgba(), QColor(255, 0, 0).rgba(), ] gridlayer = ColortableLayer(inputGrid, colortable) gridlayer.name = "Grid" gridlayer.zeroIsTransparent = True layers.insert(0, gridlayer) # Show the raw input data as a convenience for the user inputImageSlot = self.topLevelOperatorView.RawInput if inputImageSlot.ready(): inputLayer = self.createStandardLayerFromSlot(inputImageSlot) inputLayer.name = "Raw Input" inputLayer.visible = True inputLayer.opacity = 1.0 layers.append(inputLayer) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] #binct[0] = 0 ct = create_default_16bit() # associate label 0 with black/transparent? ct[0] = 0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, ct) outputLayer.name = "Connected Components" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of connected component analysis") layers.append(outputLayer) if op.Input.ready(): rawSrc = LazyflowSource(op.Input) rawLayer = ColortableLayer(outputSrc, binct) #rawLayer = self.createStandardLayerFromSlot(op.Input) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] opLane = self.topLevelOperatorView selection_names = opLane.SelectionNames.value selection = selection_names[opLane.InputSelection.value] # This code is written to handle the specific output cases we know about. # If those change, update this function! assert selection in [ "Object Predictions", "Object Probabilities", "Blockwise Object Predictions", "Blockwise Object Probabilities", "Object Identities", "Pixel Probabilities", ] if selection in ("Object Predictions", "Blockwise Object Predictions"): previewSlot = self.topLevelOperatorView.ImageToExport if previewSlot.ready(): previewLayer = ColortableLayer(createDataSource(previewSlot), colorTable=self._colorTable16) previewLayer.name = "Prediction - Preview" previewLayer.visible = False layers.append(previewLayer) elif selection in ("Object Probabilities", "Blockwise Object Probabilities"): previewLayers = self._initPredictionLayers(opLane.ImageToExport) for layer in previewLayers: layer.visible = False layer.name = layer.name + "- Preview" layers += previewLayers elif selection == "Pixel Probabilities": previewLayers = self._initPredictionLayers(opLane.ImageToExport) for layer in previewLayers: layer.visible = False layer.name = layer.name + "- Preview" layers += previewLayers elif selection == "Object Identities": previewSlot = self.topLevelOperatorView.ImageToExport layer = self._initColortableLayer(previewSlot) layers.append(layer) else: assert False, "Unknown selection." rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw Data" rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def _create_random_colortable_layer_from_slot(cls, slot, num_colors=256): colortable = generateRandomColors(num_colors, clamp={ 'v': 1.0, 's': 0.5 }, zeroIsTransparent=True) layer = ColortableLayer(LazyflowSource(slot), colortable) layer.colortableIsRandom = True return layer
def setupLayers(self): """ Called by our base class when one of our data slots has changed. This function creates a layer for each slot we want displayed in the volume editor. """ # Base class provides the label layer. layers = super(Counting3dGui, self).setupLayers() # Add each of the predictions labels = self.labelListData slots = {'density' : self.op.Density} for name, slot in slots.items(): if slot.ready(): from volumina import colortables layer = ColortableLayer(LazyflowSource(slot), colorTable = colortables.jet(), normalize = 'auto') layer.name = name layers.append(layer) boxlabelsrc = LazyflowSinkSource(self.op.BoxLabelImages,self.op.BoxLabelInputs ) boxlabellayer = ColortableLayer(boxlabelsrc, colorTable = self._colorTable16, direct = False) boxlabellayer.name = "boxLabels" boxlabellayer.opacity = 0.3 layers.append(boxlabellayer) self.boxlabelsrc = boxlabelsrc inputDataSlot = self.topLevelOperatorView.InputImages if inputDataSlot.ready(): inputLayer = self.createStandardLayerFromSlot( inputDataSlot ) inputLayer.name = "Input Data" inputLayer.visible = True inputLayer.opacity = 1.0 def toggleTopToBottom(): index = self.layerstack.layerIndex( inputLayer ) self.layerstack.selectRow( index ) if index == 0: self.layerstack.moveSelectedToBottom() else: self.layerstack.moveSelectedToTop() inputLayer.shortcutRegistration = ( "Prediction Layers", "Bring Input To Top/Bottom", QShortcut( QKeySequence("i"), self.viewerControlWidget(), toggleTopToBottom), inputLayer ) layers.append(inputLayer) self.handleLabelSelectionChange() return layers
def _initSegmentationlayer(self, segSlot): if not segSlot.ready(): return None opLane = self.topLevelOperatorView colors = opLane.PmapColors.value colortable = [] colortable.append(QColor(0, 0, 0).rgba()) for color in colors: colortable.append(QColor(*color).rgba()) segsrc = LazyflowSource(segSlot) seglayer = ColortableLayer(segsrc, colortable) seglayer.name = "Simple Segmentation" return seglayer
def _initSegmentationlayer(self, segSlot): if not segSlot.ready(): return None opLane = self.topLevelOperatorView colors = opLane.PmapColors.value colortable = [] colortable.append( QColor(0,0,0).rgba() ) for color in colors: colortable.append( QColor(*color).rgba() ) segsrc = LazyflowSource( segSlot ) seglayer = ColortableLayer( segsrc, colortable ) seglayer.name = "Simple Segmentation" return seglayer
def addCCOperator(self): self.opCC = OpConnectedComponents(self.g) self.opCC.inputs["Input"].connect(self.opThreshold.outputs["Output"]) #we shouldn't have to define these. But just in case... self.opCC.inputs["Neighborhood"].setValue(6) self.opCC.inputs["Background"].setValue(0) ccsrc = LazyflowSource(self.opCC.outputs["Output"][0]) ccsrc.setObjectName("Connected Components") ctb = colortables.create_default_16bit() ctb.insert(0, QColor(0, 0, 0, 0).rgba()) # make background transparent ccLayer = ColortableLayer(ccsrc, ctb) ccLayer.name = "Connected Components" self.layerstack.insert(1, ccLayer)
def setupLayers(self): layers = [] fromDiskSlot = self.topLevelOperatorView.ImageOnDisk if fromDiskSlot.ready(): exportLayer = ColortableLayer(LazyflowSource(fromDiskSlot), colorTable=self.ct) exportLayer.name = "Selected Output - Exported" exportLayer.visible = True layers.append(exportLayer) previewSlot = self.topLevelOperatorView.ImageToExport if previewSlot.ready(): previewLayer = ColortableLayer(LazyflowSource(previewSlot), colorTable=self.ct) previewLayer.name = "Selected Output - Preview" previewLayer.visible = False layers.append(previewLayer) rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw Data" rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [self.createStandardLayerFromSlot(self.topLevelOperatorView.Input)] layers[0].opacity = 1.0 superVoxelBoundarySlot = self.topLevelOperatorView.BoundariesOutput if superVoxelBoundarySlot.ready(): layer = AlphaModulatedLayer( LazyflowSource(superVoxelBoundarySlot), tintColor=QColor(Qt.blue), range=(0.0, 1.0), normalize=(0.0, 1.0), ) layer.name = "Supervoxel Boundaries" layer.visible = True layer.opacity = 1.0 layers.insert(0, layer) superVoxelSlot = self.topLevelOperatorView.Output if superVoxelSlot.ready(): colortable = generateRandomColors(M=256, clamp={"v": 1.0, "s": 0.5}, zeroIsTransparent=False) layer = ColortableLayer(createDataSource(superVoxelSlot), colortable) layer.colortableIsRandom = True layer.name = "SLIC Superpixels" layer.visible = True layer.opacity = 1.0 layers.insert(0, layer) return layers
def setupLayers(self): layers = [] predictionSlot = self.topLevelOperatorView.PredictionImage if predictionSlot.ready(): predictLayer = ColortableLayer(LazyflowSource(predictionSlot), colorTable=self._colorTable16) predictLayer.name = "Blockwise prediction" predictLayer.visible = False layers.append(predictLayer) binarySlot = self.topLevelOperatorView.BinaryImage if binarySlot.ready(): ct_binary = [ QColor(0, 0, 0, 0).rgba(), QColor(255, 255, 255, 255).rgba() ] binaryLayer = ColortableLayer(LazyflowSource(binarySlot), ct_binary) binaryLayer.name = "Binary Image" layers.append(binaryLayer) rawSlot = self.topLevelOperatorView.RawImage if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw data" layers.append(rawLayer) return layers
def createLabelLayer(self, direct=False): """Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelInput = self._labelingSlots.labelInput labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: self._colorTable16[15] = QColor( Qt.black).rgba() #for the objects with NaNs in features labelsrc = LazyflowSinkSource(labelOutput, labelInput) labellayer = ColortableLayer(labelsrc, colorTable=self._colorTable16, direct=direct) labellayer.segmentationImageSlot = self.op.SegmentationImagesOut labellayer.name = "Labels" labellayer.ref_object = None labellayer.zeroIsTransparent = False labellayer.colortableIsRandom = True clickInt = ClickInterpreter(self.editor, labellayer, self.onClick, right=False, double=False) self.editor.brushingInterpreter = clickInt return labellayer, labelsrc
def _create_binary_mask_layer_from_slot(cls, slot): # 0: black, 1-255: transparent # This works perfectly for uint8. # For uint32, etc., values of 256,512, etc. will be appear 'off'. # But why would you use uint32 for a binary mask anyway? colortable = [QColor(0, 0, 0, 255).rgba()] colortable += 255 * [QColor(0, 0, 0, 0).rgba()] layer = ColortableLayer(LazyflowSource(slot), colortable) return layer
def createCropLayer(self, direct=False): """ Return a colortable layer that displays the crop slot data, along with its associated crop source. direct: whether this layer is drawn synchronously by volumina """ cropOutput = self._croppingSlots.cropOutput if not cropOutput.ready(): return (None, None) else: # Add the layer to draw the crops, but don't add any crops cropsrc = LazyflowSinkSource( self._croppingSlots.cropOutput, self._croppingSlots.cropInput) croplayer = ColortableLayer(cropsrc, colorTable = self._colorTable16, direct=direct ) croplayer.name = "Crops" croplayer.ref_object = None return croplayer, cropsrc
def createLabelLayer(self, direct=False): """ Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: traceLogger.debug("Setting up labels") # Add the layer to draw the labels, but don't add any labels labelsrc = LazyflowSinkSource(self._labelingSlots.labelOutput, self._labelingSlots.labelInput) labellayer = ColortableLayer(labelsrc, colorTable=self._colorTable16, direct=direct) labellayer.name = "Labels" labellayer.ref_object = None return labellayer, labelsrc
def setupLayers(self): mainOperator = self.topLevelOperatorView layers = [] if mainOperator.ObjectCenterImage.ready(): self.centerimagesrc = LazyflowSource(mainOperator.ObjectCenterImage) #layer = RGBALayer(red=ConstantSource(255), alpha=self.centerimagesrc) redct = [0, QColor(255, 0, 0).rgba()] layer = ColortableLayer(self.centerimagesrc, redct) layer.name = "Object Centers" layer.visible = False layers.append(layer) ct = colortables.create_default_16bit() if mainOperator.LabelImage.ready(): self.objectssrc = LazyflowSource(mainOperator.LabelImage) self.objectssrc.setObjectName("LabelImage LazyflowSrc") ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent layer = ColortableLayer(self.objectssrc, ct) layer.name = "Label Image" layer.visible = False layer.opacity = 0.5 layers.append(layer) # white foreground on transparent background binct = [QColor(0, 0, 0, 0).rgba(), QColor(255, 255, 255, 255).rgba()] if mainOperator.BinaryImage.ready(): self.binaryimagesrc = LazyflowSource(mainOperator.BinaryImage) self.binaryimagesrc.setObjectName("Binary LazyflowSrc") layer = ColortableLayer(self.binaryimagesrc, binct) layer.name = "Binary Image" layers.append(layer) ## raw data layer self.rawsrc = None self.rawsrc = LazyflowSource(mainOperator.RawImage) self.rawsrc.setObjectName("Raw Lazyflow Src") layerraw = GrayscaleLayer(self.rawsrc) layerraw.name = "Raw" layers.insert(len(layers), layerraw) mainOperator.RawImage.notifyReady(self._onReady) mainOperator.RawImage.notifyMetaChanged(self._onMetaChanged) if mainOperator.BinaryImage.meta.shape: self.editor.dataShape = mainOperator.BinaryImage.meta.shape mainOperator.BinaryImage.notifyMetaChanged(self._onMetaChanged) return layers
def _initColortableLayer(self, labelSlot): objectssrc = createDataSource(labelSlot) objectssrc.setObjectName("LabelImage LazyflowSrc") ct = colortables.create_default_16bit() ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent layer = ColortableLayer(objectssrc, ct) layer.name = "Object Identities - Preview" layer.setToolTip("Segmented objects, shown in different colors") layer.visible = False layer.opacity = 0.5 layer.colortableIsRandom = True return layer
def addThresholdOperator(self): if self.opThreshold is None: self.opThreshold = OpThreshold(self.g) self.opThreshold.inputs["Input"].connect(self.pCache.outputs["Output"]) #channel, value = ThresholdDlg(self.labelListModel._labels) channel = 0 value = 0.5 ref_label = self.labelListModel._labels[channel] self.opThreshold.inputs["Channel"].setValue(channel) self.opThreshold.inputs["Threshold"].setValue(value) threshsrc = LazyflowSource(self.opThreshold.outputs["Output"][0]) threshsrc.setObjectName("Threshold for %s" % ref_label.name) transparent = QColor(0,0,0,0) white = QColor(255,255,255) colorTable = [transparent.rgba(), white.rgba()] threshLayer = ColortableLayer(threshsrc, colorTable = colorTable ) threshLayer.name = "Threshold for %s" % ref_label.name self.layerstack.insert(1, threshLayer) self.CCButton.setEnabled(True)
def createLabelLayer(self, direct=False): """ Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: # Add the layer to draw the labels, but don't add any labels labelsrc = LazyflowSinkSource( self._labelingSlots.labelOutput, self._labelingSlots.labelInput) labellayer = ColortableLayer(labelsrc, colorTable = self._colorTable16, direct=direct ) labellayer.name = "Labels" labellayer.ref_object = None labellayer.contexts.append(("Import...", partial( import_labeling_layer, labellayer, self._labelingSlots, self ))) return labellayer, labelsrc
def _initPredictionLayers(self, predictionSlot): layers = [] opLane = self.topLevelOperatorView if predictionSlot.ready() and self.topLevelOperatorView.UpperBound.ready(): upperBound = self.topLevelOperatorView.UpperBound.value layer = ColortableLayer(LazyflowSource(predictionSlot), colorTable = countingColorTable, normalize = (0,upperBound)) layer.name = "Density" layers.append(layer) # def _initPredictionLayers(self, predictionSlot): # layers = [] # # opLane = self.topLevelOperatorView # colors = opLane.PmapColors.value # names = opLane.LabelNames.value # # # Use a slicer to provide a separate slot for each channel layer # opSlicer = OpMultiArraySlicer2( parent=opLane.viewed_operator() ) # opSlicer.Input.connect( predictionSlot ) # opSlicer.AxisFlag.setValue('c') # # for channel, channelSlot in enumerate(opSlicer.Slices): # if channelSlot.ready() and channel < len(colors) and channel < len(names): # drange = channelSlot.meta.drange or (0.0, 1.0) # predictsrc = LazyflowSource(channelSlot) # predictLayer = AlphaModulatedLayer( predictsrc, # tintColor=QColor(*colors[channel]), # # FIXME: This is weird. Why are range and normalize both set to the same thing? # range=drange, # normalize=drange ) # predictLayer.opacity = 0.25 # predictLayer.visible = True # predictLayer.name = names[channel] # layers.append(predictLayer) return layers
def _initPredictionLayers(self, predictionSlot): layers = [] opLane = self.topLevelOperatorView if predictionSlot.ready( ) and self.topLevelOperatorView.UpperBound.ready(): upperBound = self.topLevelOperatorView.UpperBound.value layer = ColortableLayer(createDataSource(predictionSlot), colorTable=countingColorTable, normalize=(0, upperBound)) layer.name = "Density" layers.append(layer) # def _initPredictionLayers(self, predictionSlot): # layers = [] # # opLane = self.topLevelOperatorView # colors = opLane.PmapColors.value # names = opLane.LabelNames.value # # # Use a slicer to provide a separate slot for each channel layer # opSlicer = OpMultiArraySlicer2( parent=opLane.viewed_operator() ) # opSlicer.Input.connect( predictionSlot ) # opSlicer.AxisFlag.setValue('c') # # for channel, channelSlot in enumerate(opSlicer.Slices): # if channelSlot.ready() and channel < len(colors) and channel < len(names): # drange = channelSlot.meta.drange or (0.0, 1.0) # predictsrc = createDataSource(channelSlot) # predictLayer = AlphaModulatedLayer( predictsrc, # tintColor=QColor(*colors[channel]), # # FIXME: This is weird. Why are range and normalize both set to the same thing? # range=drange, # normalize=drange ) # predictLayer.opacity = 0.25 # predictLayer.visible = True # predictLayer.name = names[channel] # layers.append(predictLayer) return layers
def createLabelLayer(self, direct=False): """Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelInput = self._labelingSlots.labelInput labelOutput = self._labelingSlots.labelOutput if not labelOutput.ready(): return (None, None) else: self._colorTable16[15] = QColor(Qt.black).rgba() #for the objects with NaNs in features labelsrc = LazyflowSinkSource(labelOutput, labelInput) labellayer = ColortableLayer(labelsrc, colorTable=self._colorTable16, direct=direct) labellayer.segmentationImageSlot = self.op.SegmentationImagesOut labellayer.name = "Labels" labellayer.ref_object = None labellayer.zeroIsTransparent = False labellayer.colortableIsRandom = True clickInt = ClickInterpreter(self.editor, labellayer, self.onClick, right=False, double=False) self.editor.brushingInterpreter = clickInt return labellayer, labelsrc
def setupLayers(self): layers = [] fromDiskSlot = self.topLevelOperatorView.ImageOnDisk if fromDiskSlot.ready(): exportLayer = ColortableLayer( LazyflowSource(fromDiskSlot), colorTable=self.ct ) exportLayer.name = "Tracking - Exported" exportLayer.visible = True layers.append(exportLayer) previewSlot = self.topLevelOperatorView.ImageToExport if previewSlot.ready(): previewLayer = ColortableLayer( LazyflowSource(previewSlot), colorTable=self.ct ) previewLayer.name = "Tracking - Preview" previewLayer.visible = False layers.append(previewLayer) rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw Data" rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] opLane = self.topLevelOperatorView labelSlot = opLane.LabelImage if labelSlot.ready(): labelImageLayer = ColortableLayer(LazyflowSource(labelSlot), colorTable=self._colorTable16) labelImageLayer.name = "Label Image" labelImageLayer.visible = True layers.append(labelImageLayer) # If available, also show the raw data layer rawSlot = opLane.RawImage if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw Data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] opLane = self.topLevelOperatorView labelSlot = opLane.LabelImage if labelSlot.ready(): labelImageLayer = ColortableLayer( LazyflowSource(labelSlot), colorTable=self._colorTable16 ) labelImageLayer.name = "Label Image" labelImageLayer.visible = True layers.append(labelImageLayer) # If available, also show the raw data layer rawSlot = opLane.RawImage if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot( rawSlot ) rawLayer.name = "Raw Data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append( rawLayer ) return layers
def createLabelLayer(self, currentImageIndex, direct=False): """ Return a colortable layer that displays the label slot data, along with its associated label source. direct: whether this layer is drawn synchronously by volumina """ labelOutput = self._labelingSlots.labelOutput[currentImageIndex] if not labelOutput.ready(): return (None, None) else: traceLogger.debug("Setting up labels for image index={}".format( currentImageIndex)) # Add the layer to draw the labels, but don't add any labels labelsrc = LazyflowSinkSource( self._labelingSlots.labelOutput[currentImageIndex], self._labelingSlots.labelInput[currentImageIndex]) labellayer = ColortableLayer(labelsrc, colorTable=self._colorTable16, direct=direct) labellayer.name = "Labels" labellayer.ref_object = None return labellayer, labelsrc
def setupLayers(self): """ Overridden from LayerViewerGui. Create a list of all layer objects that should be displayed. """ layers = [] # Show the raw input data inputImageSlot = self.topLevelOperatorView.InputImage if inputImageSlot.ready(): inputLayer = self.createStandardLayerFromSlot(inputImageSlot) inputLayer.name = "Raw Input" inputLayer.visible = True inputLayer.opacity = 1.0 layers.append(inputLayer) outputImageSlot = self.topLevelOperatorView.Output if outputImageSlot.ready(): outputLayer = self.createStandardLayerFromSlot(outputImageSlot) outputLayer.name = "Result" outputLayer.visible = False outputLayer.opacity = 1.0 layers.append(outputLayer) outputThresholdSlot = self.topLevelOperatorView.OutputThreshold if outputThresholdSlot.ready(): # thresholdLayer = self.createStandardLayerFromSlot(outputThresholdSlot) thresholdLayer = ColortableLayer( LazyflowSource(outputThresholdSlot), colorTable=self._colorTable16) thresholdLayer.name = "Thresholded" thresholdLayer.visible = False thresholdLayer.opacity = 1.0 layers.append(thresholdLayer) return layers
def _initColortablelayer(self, segSlot): """ Used to export both segmentation and labels """ if not segSlot.ready(): return None opLane = self.topLevelOperatorView colors = opLane.PmapColors.value colortable = [] colortable.append(QColor(0, 0, 0, 0).rgba()) # transparent for color in colors: colortable.append(QColor(*color).rgba()) segsrc = LazyflowSource(segSlot) seglayer = ColortableLayer(segsrc, colortable) return seglayer
def _initColortablelayer(self, labelSlot): """ Used to export labels """ if not labelSlot.ready(): return None opLane = self.topLevelOperatorView colors = opLane.PmapColors.value colortable = [] colortable.append(QColor(0, 0, 0, 0).rgba()) # transparent for color in colors: colortable.append(QColor(*color).rgba()) labelsrc = LazyflowSource(labelSlot) labellayer = ColortableLayer(labelsrc, colortable) return labellayer
def setupLayers(self): # Base class provides the label layer. layers = super(ObjectClassificationGui, self).setupLayers() binarySlot = self.op.BinaryImages segmentedSlot = self.op.SegmentationImages rawSlot = self.op.RawImages #This is just for colors labels = self.labelListData for channel, probSlot in enumerate(self.op.PredictionProbabilityChannels): if probSlot.ready() and channel < len(labels): ref_label = labels[channel] probsrc = LazyflowSource(probSlot) probLayer = AlphaModulatedLayer( probsrc, tintColor=ref_label.pmapColor(), range=(0.0, 1.0), normalize=(0.0, 1.0) ) probLayer.opacity = 0.25 #probLayer.visible = self.labelingDrawerUi.checkInteractive.isChecked() #False, because it's much faster to draw predictions without these layers below probLayer.visible = False probLayer.setToolTip("Probability that the object belongs to class {}".format(channel+1)) def setLayerColor(c, predictLayer_=probLayer, ch=channel, initializing=False): if not initializing and predictLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return predictLayer_.tintColor = c def setLayerName(n, predictLayer_=probLayer, initializing=False): if not initializing and predictLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return newName = "Prediction for %s" % n predictLayer_.name = newName setLayerName(ref_label.name, initializing=True) ref_label.pmapColorChanged.connect(setLayerColor) ref_label.nameChanged.connect(setLayerName) layers.append(probLayer) predictionSlot = self.op.PredictionImages if predictionSlot.ready(): predictsrc = LazyflowSource(predictionSlot) self._colorTable16_forpmaps[0] = 0 predictLayer = ColortableLayer(predictsrc, colorTable=self._colorTable16_forpmaps) predictLayer.name = self.PREDICTION_LAYER_NAME predictLayer.ref_object = None predictLayer.visible = self.labelingDrawerUi.checkInteractive.isChecked() predictLayer.opacity = 0.5 predictLayer.setToolTip("Classification results, assigning a label to each object") # This weakref stuff is a little more fancy than strictly necessary. # The idea is to use the weakref's callback to determine when this layer instance is destroyed by the garbage collector, # and then we disconnect the signal that updates that layer. weak_predictLayer = weakref.ref( predictLayer ) colortable_changed_callback = bind( self._setPredictionColorTable, weak_predictLayer ) self._labelControlUi.labelListModel.dataChanged.connect( colortable_changed_callback ) weak_predictLayer2 = weakref.ref( predictLayer, partial(self._disconnect_dataChange_callback, colortable_changed_callback) ) # We have to make sure the weakref isn't destroyed because it is responsible for calling the callback. # Therefore, we retain it by adding it to a list. self._retained_weakrefs.append( weak_predictLayer2 ) # Ensure we're up-to-date (in case this is the first time the prediction layer is being added. for row in range( self._labelControlUi.labelListModel.rowCount() ): self._setPredictionColorTableForRow( predictLayer, row ) # put right after Labels, so that it is visible after hitting "live # predict". layers.insert(1, predictLayer) badObjectsSlot = self.op.BadObjectImages if badObjectsSlot.ready(): ct_black = [0, QColor(Qt.black).rgba()] badSrc = LazyflowSource(badObjectsSlot) badLayer = ColortableLayer(badSrc, colorTable = ct_black) badLayer.name = "Ambiguous objects" badLayer.setToolTip("Objects with infinite or invalid values in features") badLayer.visible = False layers.append(badLayer) if segmentedSlot.ready(): ct = colortables.create_default_16bit() objectssrc = LazyflowSource(segmentedSlot) ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent objLayer = ColortableLayer(objectssrc, ct) objLayer.name = "Objects" objLayer.opacity = 0.5 objLayer.visible = False objLayer.setToolTip("Segmented objects (labeled image/connected components)") layers.append(objLayer) if binarySlot.ready(): ct_binary = [0, QColor(255, 255, 255, 255).rgba()] # white foreground on transparent background, even for labeled images binct = [QColor(255, 255, 255, 255).rgba()]*65536 binct[0] = 0 binaryimagesrc = LazyflowSource(binarySlot) binLayer = ColortableLayer(binaryimagesrc, binct) binLayer.name = "Binary image" binLayer.visible = True binLayer.opacity = 1.0 binLayer.setToolTip("Segmentation results as a binary mask") layers.append(binLayer) if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw data" def toggleTopToBottom(): index = self.layerstack.layerIndex( rawLayer ) self.layerstack.selectRow( index ) if index == 0: self.layerstack.moveSelectedToBottom() else: self.layerstack.moveSelectedToTop() ActionInfo = ShortcutManager.ActionInfo rawLayer.shortcutRegistration = ( "i", ActionInfo( "Prediction Layers", "Bring Input To Top/Bottom", "Bring Input To Top/Bottom", toggleTopToBottom, self.viewerControlWidget(), rawLayer ) ) layers.append(rawLayer) # since we start with existing labels, it makes sense to start # with the first one selected. This would make more sense in # __init__(), but it does not take effect there. #self.selectLabel(0) return layers
def setupLayers(self): # Base class provides the label layer and the raw layer layers = super(ObjectClassificationGui, self).setupLayers() binarySlot = self.op.BinaryImages atlas_slot = self.op.Atlas segmentedSlot = self.op.SegmentationImages #This is just for colors labels = self.labelListData for channel, probSlot in enumerate( self.op.PredictionProbabilityChannels): if probSlot.ready() and channel < len(labels): ref_label = labels[channel] probsrc = LazyflowSource(probSlot) probLayer = AlphaModulatedLayer( probsrc, tintColor=ref_label.pmapColor(), range=(0.0, 1.0), normalize=(0.0, 1.0)) probLayer.opacity = 0.25 #probLayer.visible = self.labelingDrawerUi.checkInteractive.isChecked() #False, because it's much faster to draw predictions without these layers below probLayer.visible = False probLayer.setToolTip( "Probability that the object belongs to class {}".format( channel + 1)) def setLayerColor(c, predictLayer_=probLayer, ch=channel, initializing=False): if not initializing and predictLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return predictLayer_.tintColor = c def setLayerName(n, predictLayer_=probLayer, initializing=False): if not initializing and predictLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return newName = "Prediction for %s" % n predictLayer_.name = newName setLayerName(ref_label.name, initializing=True) ref_label.pmapColorChanged.connect(setLayerColor) ref_label.nameChanged.connect(setLayerName) layers.append(probLayer) predictionSlot = self.op.PredictionImages if predictionSlot.ready(): predictsrc = LazyflowSource(predictionSlot) self._colorTable16_forpmaps[0] = 0 predictLayer = ColortableLayer( predictsrc, colorTable=self._colorTable16_forpmaps) predictLayer.name = self.PREDICTION_LAYER_NAME predictLayer.ref_object = None predictLayer.opacity = 0.5 predictLayer.setToolTip( "Classification results, assigning a label to each object") # This weakref stuff is a little more fancy than strictly necessary. # The idea is to use the weakref's callback to determine when this layer instance is destroyed by the garbage collector, # and then we disconnect the signal that updates that layer. weak_predictLayer = weakref.ref(predictLayer) colortable_changed_callback = bind(self._setPredictionColorTable, weak_predictLayer) self._labelControlUi.labelListModel.dataChanged.connect( colortable_changed_callback) weak_predictLayer2 = weakref.ref( predictLayer, partial(self._disconnect_dataChange_callback, colortable_changed_callback)) # We have to make sure the weakref isn't destroyed because it is responsible for calling the callback. # Therefore, we retain it by adding it to a list. self._retained_weakrefs.append(weak_predictLayer2) # Ensure we're up-to-date (in case this is the first time the prediction layer is being added. for row in range(self._labelControlUi.labelListModel.rowCount()): self._setPredictionColorTableForRow(predictLayer, row) # put right after Labels, so that it is visible after hitting "live # predict". layers.insert(1, predictLayer) badObjectsSlot = self.op.BadObjectImages if badObjectsSlot.ready(): ct_black = [0, QColor(Qt.black).rgba()] badSrc = LazyflowSource(badObjectsSlot) badLayer = ColortableLayer(badSrc, colorTable=ct_black) badLayer.name = "Ambiguous objects" badLayer.setToolTip( "Objects with infinite or invalid values in features") badLayer.visible = False layers.append(badLayer) if segmentedSlot.ready(): ct = colortables.create_default_16bit() objectssrc = LazyflowSource(segmentedSlot) ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent objLayer = ColortableLayer(objectssrc, ct) objLayer.name = "Objects" objLayer.opacity = 0.5 objLayer.visible = False objLayer.setToolTip( "Segmented objects (labeled image/connected components)") layers.append(objLayer) uncertaintySlot = self.op.UncertaintyEstimateImage if uncertaintySlot.ready(): uncertaintySrc = LazyflowSource(uncertaintySlot) uncertaintyLayer = AlphaModulatedLayer(uncertaintySrc, tintColor=QColor(Qt.cyan), range=(0.0, 1.0), normalize=(0.0, 1.0)) uncertaintyLayer.name = "Uncertainty" uncertaintyLayer.visible = False uncertaintyLayer.opacity = 1.0 ActionInfo = ShortcutManager.ActionInfo uncertaintyLayer.shortcutRegistration = ( "u", ActionInfo("Uncertainty Layers", "Uncertainty", "Show/Hide Uncertainty", uncertaintyLayer.toggleVisible, self.viewerControlWidget(), uncertaintyLayer)) layers.append(uncertaintyLayer) if binarySlot.ready(): ct_binary = [0, QColor(255, 255, 255, 255).rgba()] # white foreground on transparent background, even for labeled images binct = [QColor(255, 255, 255, 255).rgba()] * 65536 binct[0] = 0 binaryimagesrc = LazyflowSource(binarySlot) binLayer = ColortableLayer(binaryimagesrc, binct) binLayer.name = "Binary image" binLayer.visible = True binLayer.opacity = 1.0 binLayer.setToolTip("Segmentation results as a binary mask") layers.append(binLayer) if atlas_slot.ready(): layers.append( self.createStandardLayerFromSlot(atlas_slot, name="Atlas", opacity=0.5)) # since we start with existing labels, it makes sense to start # with the first one selected. This would make more sense in # __init__(), but it does not take effect there. #self.selectLabel(0) return layers
def setupLayers( self ): layers = [] self.ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent self.ct[255] = QColor(0,0,0,255).rgba() # make -1 black self.ct[-1] = QColor(0,0,0,255).rgba() self.trackingsrc = LazyflowSource( self.topLevelOperatorView.TrackImage ) trackingLayer = ColortableLayer( self.trackingsrc, self.ct ) trackingLayer.name = "Manual Tracking" trackingLayer.visible = True trackingLayer.opacity = 0.8 def toggleTrackingVisibility(): trackingLayer.visible = not trackingLayer.visible trackingLayer.shortcutRegistration = ( "Layer Visibilities", "Toggle Manual Tracking Layer Visibility", QtGui.QShortcut( QtGui.QKeySequence("e"), self.viewerControlWidget(), toggleTrackingVisibility), trackingLayer ) layers.append(trackingLayer) ct = colortables.create_random_16bit() ct[1] = QColor(230,0,0,150).rgba() ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent self.untrackedsrc = LazyflowSource( self.topLevelOperatorView.UntrackedImage ) untrackedLayer = ColortableLayer( self.untrackedsrc, ct ) untrackedLayer.name = "Untracked Objects" untrackedLayer.visible = False untrackedLayer.opacity = 0.8 layers.append(untrackedLayer) self.objectssrc = LazyflowSource( self.topLevelOperatorView.BinaryImage ) ct = colortables.create_random_16bit() ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent ct[1] = QColor(255,255,0,100).rgba() objLayer = ColortableLayer( self.objectssrc, ct ) objLayer.name = "Objects" objLayer.opacity = 0.8 objLayer.visible = True def toggleObjectVisibility(): objLayer.visible = not objLayer.visible objLayer.shortcutRegistration = ( "Layer Visibilities", "Toggle Objects Layer Visibility", QtGui.QShortcut( QtGui.QKeySequence("r"), self.viewerControlWidget(), toggleObjectVisibility), objLayer ) layers.append(objLayer) ## raw data layer self.rawsrc = None self.rawsrc = LazyflowSource( self.mainOperator.RawImage ) rawLayer = GrayscaleLayer( self.rawsrc ) rawLayer.name = "Raw" layers.insert( len(layers), rawLayer ) if self.topLevelOperatorView.LabelImage.meta.shape: self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape self.topLevelOperatorView.RawImage.notifyReady( self._onReady ) self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged ) self._setDivisionsList() self._setActiveTrackList() return layers
def setupLayers(self): layers = [] if "MergerOutput" in self.topLevelOperatorView.outputs and self.topLevelOperatorView.MergerOutput.ready( ): ct = colortables.create_default_8bit() for i in range(7): ct[i] = self.mergerColors[i].rgba() self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerOutput) mergerLayer = ColortableLayer(self.mergersrc, ct) mergerLayer.name = "Merger" mergerLayer.visible = True layers.append(mergerLayer) ct = colortables.create_random_16bit() ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent ct[1] = QColor(128, 128, 128, 255).rgba( ) # misdetections have id 1 and will be indicated by grey if self.topLevelOperatorView.CachedOutput.ready(): self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput) trackingLayer = ColortableLayer(self.trackingsrc, ct) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) elif self.topLevelOperatorView.zeroProvider.Output.ready(): # provide zeros while waiting for the tracking result self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output) trackingLayer = ColortableLayer(self.trackingsrc, ct) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) if self.topLevelOperatorView.LabelImage.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage) ct = colortables.create_random_16bit() ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent objLayer = ColortableLayer(self.objectssrc, ct) objLayer.name = "Objects" objLayer.opacity = 1.0 objLayer.visible = True layers.append(objLayer) if self.mainOperator.RawImage.ready(): self.rawsrc = None self.rawsrc = LazyflowSource(self.mainOperator.RawImage) rawLayer = GrayscaleLayer(self.rawsrc) rawLayer.name = "Raw" layers.insert(len(layers), rawLayer) if self.topLevelOperatorView.LabelImage.meta.shape: self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1 maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1 maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1 maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1 if not self.mainOperator.Parameters.ready(): raise Exception("Parameter slot is not ready") parameters = self.mainOperator.Parameters.value self._setRanges() if 'size_range' in parameters: self._drawer.to_size.setValue(parameters['size_range'][1] - 1) self._drawer.from_size.setValue(parameters['size_range'][0]) else: self._drawer.from_size.setValue(0) self._drawer.to_size.setValue(10000) if 'x_range' in parameters: self._drawer.to_x.setValue(parameters['x_range'][1] - 1) self._drawer.from_x.setValue(parameters['x_range'][0]) else: self._drawer.from_x.setValue(0) self._drawer.to_x.setValue(maxx) if 'y_range' in parameters: self._drawer.to_y.setValue(parameters['y_range'][1] - 1) self._drawer.from_y.setValue(parameters['y_range'][0]) else: self._drawer.from_y.setValue(0) self._drawer.to_y.setValue(maxy) if 'z_range' in parameters: self._drawer.to_z.setValue(parameters['z_range'][1] - 1) self._drawer.from_z.setValue(parameters['z_range'][0]) else: self._drawer.from_z.setValue(0) self._drawer.to_z.setValue(maxz) if 'time_range' in parameters: self._drawer.to_time.setValue(parameters['time_range'][1]) self._drawer.from_time.setValue(parameters['time_range'][0]) else: self._drawer.from_time.setValue(0) self._drawer.to_time.setValue(maxt) if 'scales' in parameters: self._drawer.x_scale.setValue(parameters['scales'][0]) self._drawer.y_scale.setValue(parameters['scales'][1]) self._drawer.z_scale.setValue(parameters['scales'][2]) else: self._drawer.x_scale.setValue(1) self._drawer.y_scale.setValue(1) self._drawer.z_scale.setValue(1) self.topLevelOperatorView.RawImage.notifyReady(self._onReady) self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] binct[0] = 0 ct = self._createDefault16ColorColorTable() ct[0]=0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, binct) outputLayer.name = "Final output" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of thresholding and size filter") layers.append(outputLayer) if self._showDebug: #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = self._drawer.tabWidget.currentIndex() if curIndex==1: if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer(lowThresholdSrc, binct) lowThresholdLayer.name = "After low threshold" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 lowThresholdLayer.setToolTip("Results of thresholding with the low pixel value threshold") layers.append(lowThresholdLayer) if op.FilteredSmallLabels.ready(): filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels ) filteredSmallLabelsLayer.name = "After high threshold and size filter" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 filteredSmallLabelsLayer.setToolTip("Results of thresholding with the high pixel value threshold,\ followed by the size filter") layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer(highThresholdSrc, binct) highThresholdLayer.name = "After high threshold" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 highThresholdLayer.setToolTip("Results of thresholding with the high pixel value threshold") layers.append(highThresholdLayer) elif curIndex==0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer(thSrc, ct) thLayer.name = "Before size filter" thLayer.visible = False thLayer.opacity = 1.0 thLayer.setToolTip("Results of thresholding before the size filter is applied") layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot( op.Smoothed ) smoothedLayer.name = "Smoothed input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 smoothedLayer.setToolTip("Selected channel data, smoothed with a Gaussian with user-defined sigma") layers.append(smoothedLayer) # Show the selected channel if op.InputChannel.ready(): drange = op.InputChannel.meta.drange if drange is None: drange = (0.0, 1.0) channelSrc = LazyflowSource(op.InputChannel) #channelLayer = AlphaModulatedLayer( channelSrc, # tintColor=QColor(self._channelColors[op.Channel.value]), # range=drange, # normalize=drange ) #it used to be set to the label color, but people found it confusing channelLayer = AlphaModulatedLayer( channelSrc, tintColor = QColor(Qt.white), range = drange, normalize=drange) channelLayer.name = "Selected input channel" channelLayer.opacity = 1.0 channelLayer.setToolTip("The selected channel of the prediction images") #channelLayer.visible = channelIndex == op.Channel.value # By default, only the selected input channel is visible. layers.append(channelLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot( rawSlot ) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] binct[0] = 0 ct = create_default_16bit() ct[0]=0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, ct) outputLayer.name = "Final output" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of thresholding and size filter") layers.append(outputLayer) if op.InputImage.ready(): numChannels = op.InputImage.meta.getTaggedShape()['c'] for channel in range(numChannels): channelProvider = OpSingleChannelSelector(parent=op.InputImage.getRealOperator().parent) channelProvider.Input.connect(op.InputImage) channelProvider.Index.setValue( channel ) channelSrc = LazyflowSource( channelProvider.Output ) inputChannelLayer = AlphaModulatedLayer( channelSrc, tintColor=QColor(self._channelColors[channel]), range=(0.0, 1.0), normalize=(0.0, 1.0) ) inputChannelLayer.opacity = 0.5 inputChannelLayer.visible = True inputChannelLayer.name = "Input Channel " + str(channel) inputChannelLayer.setToolTip("Select input channel " + str(channel) + \ " if this prediction image contains the objects of interest.") layers.append(inputChannelLayer) if self._showDebug: #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = self._drawer.tabWidget.currentIndex() if curIndex==1: if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer(lowThresholdSrc, binct) lowThresholdLayer.name = "After low threshold" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 lowThresholdLayer.setToolTip("Results of thresholding with the low pixel value threshold") layers.append(lowThresholdLayer) if op.FilteredSmallLabels.ready(): filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels ) filteredSmallLabelsLayer.name = "After high threshold and size filter" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 filteredSmallLabelsLayer.setToolTip("Results of thresholding with the high pixel value threshold,\ followed by the size filter") layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer(highThresholdSrc, binct) highThresholdLayer.name = "After high threshold" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 highThresholdLayer.setToolTip("Results of thresholding with the high pixel value threshold") layers.append(highThresholdLayer) elif curIndex==0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer(thSrc, ct) thLayer.name = "Before size filter" thLayer.visible = False thLayer.opacity = 1.0 thLayer.setToolTip("Results of thresholding before the size filter is applied") layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot( op.Smoothed ) smoothedLayer.name = "Smoothed input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 smoothedLayer.setToolTip("Selected channel data, smoothed with a Gaussian with user-defined sigma") layers.append(smoothedLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot( rawSlot ) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): # Base class provides the label layer. layers = super(ObjectClassificationGui, self).setupLayers() labelOutput = self._labelingSlots.labelOutput binarySlot = self.op.BinaryImages segmentedSlot = self.op.SegmentationImages rawSlot = self.op.RawImages if segmentedSlot.ready(): ct = colortables.create_default_16bit() self.objectssrc = LazyflowSource(segmentedSlot) ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent layer = ColortableLayer(self.objectssrc, ct) layer.name = "Objects" layer.opacity = 0.5 layer.visible = True layers.append(layer) if binarySlot.ready(): ct_binary = [QColor(0, 0, 0, 0).rgba(), QColor(255, 255, 255, 255).rgba()] self.binaryimagesrc = LazyflowSource(binarySlot) layer = ColortableLayer(self.binaryimagesrc, ct_binary) layer.name = "Binary Image" layer.visible = False layers.append(layer) # This is just for colors labels = self.labelListData for channel, probSlot in enumerate(self.op.PredictionProbabilityChannels): if probSlot.ready() and channel < len(labels): ref_label = labels[channel] probsrc = LazyflowSource(probSlot) probLayer = AlphaModulatedLayer( probsrc, tintColor=ref_label.pmapColor(), range=(0.0, 1.0), normalize=(0.0, 1.0) ) probLayer.opacity = 0.25 probLayer.visible = self.labelingDrawerUi.checkInteractive.isChecked() def setLayerColor(c, predictLayer=probLayer): predictLayer.tintColor = c def setLayerName(n, predictLayer=probLayer): newName = "Prediction for %s" % n predictLayer.name = newName setLayerName(ref_label.name) ref_label.pmapColorChanged.connect(setLayerColor) ref_label.nameChanged.connect(setLayerName) layers.insert(0, probLayer) predictionSlot = self.op.PredictionImages if predictionSlot.ready(): self.predictsrc = LazyflowSource(predictionSlot) self.predictlayer = ColortableLayer(self.predictsrc, colorTable=self._colorTable16) self.predictlayer.name = "Prediction" self.predictlayer.ref_object = None self.predictlayer.visible = self.labelingDrawerUi.checkInteractive.isChecked() # put first, so that it is visible after hitting "live # predict". layers.insert(0, self.predictlayer) badObjectsSlot = self.op.BadObjectImages if badObjectsSlot.ready(): ct_black = [0, QColor(Qt.black).rgba()] self.badSrc = LazyflowSource(badObjectsSlot) self.badLayer = ColortableLayer(self.badSrc, colorTable=ct_black) self.badLayer.name = "Ambiguous objects" self.badLayer.visible = False layers.append(self.badLayer) if rawSlot.ready(): self.rawimagesrc = LazyflowSource(rawSlot) layer = self.createStandardLayerFromSlot(rawSlot) layer.name = "Raw data" layers.append(layer) # since we start with existing labels, it makes sense to start # with the first one selected. This would make more sense in # __init__(), but it does not take effect there. # self.selectLabel(0) return layers
def setupLayers( self ): layers = [] # use same colortable for the following two generated layers: the merger # and the tracking layer self.tracking_colortable = colortables.create_random_16bit() self.tracking_colortable[0] = QColor(0,0,0,0).rgba() # make 0 transparent self.tracking_colortable[1] = QColor(128,128,128,255).rgba() # misdetections have id 1 and will be indicated by grey self.merger_colortable = colortables.create_default_16bit() for i in range(7): self.merger_colortable[i] = self.mergerColors[i].rgba() if "MergerOutput" in self.topLevelOperatorView.outputs: parameters = self.mainOperator.Parameters.value if 'withMergerResolution' in parameters.keys() and not parameters['withMergerResolution']: merger_ct = self.merger_colortable else: merger_ct = self.tracking_colortable # Using same color table for tracking with and without mergers (Is there any reason for using different color tables?) merger_ct = self.tracking_colortable if self.topLevelOperatorView.MergerCachedOutput.ready(): self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerCachedOutput ) else: self.mergersrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output ) mergerLayer = ColortableLayer( self.mergersrc, merger_ct ) mergerLayer.name = "Merger" if 'withMergerResolution' in parameters.keys() and not parameters['withMergerResolution']: mergerLayer.visible = True else: mergerLayer.visible = False layers.append(mergerLayer) if self.topLevelOperatorView.CachedOutput.ready(): self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput ) trackingLayer = ColortableLayer( self.trackingsrc, self.tracking_colortable ) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) elif self.topLevelOperatorView.zeroProvider.Output.ready(): # provide zeros while waiting for the tracking result self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output ) trackingLayer = ColortableLayer( self.trackingsrc, self.tracking_colortable ) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) if "RelabeledImage" in self.topLevelOperatorView.outputs: if self.topLevelOperatorView.RelabeledCachedOutput.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.RelabeledCachedOutput ) else: self.objectssrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output ) else: if self.topLevelOperatorView.LabelImage.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage ) ct = colortables.create_random_16bit() ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent objLayer = ColortableLayer( self.objectssrc, ct ) objLayer.name = "Objects" objLayer.opacity = 1.0 objLayer.visible = False layers.append(objLayer) if self.mainOperator.RawImage.ready(): rawLayer = self.createStandardLayerFromSlot(self.mainOperator.RawImage) rawLayer.name = "Raw" layers.insert( len(layers), rawLayer ) if self.topLevelOperatorView.LabelImage.meta.shape: maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1 maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1 maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1 maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1 if not self.mainOperator.Parameters.ready(): raise Exception("Parameter slot is not ready") parameters = self.mainOperator.Parameters.value self._setRanges() if 'size_range' in parameters: self._drawer.to_size.setValue(parameters['size_range'][1]-1) self._drawer.from_size.setValue(parameters['size_range'][0]) else: self._drawer.from_size.setValue(0) self._drawer.to_size.setValue(10000) if 'x_range' in parameters: self._drawer.to_x.setValue(parameters['x_range'][1]-1) self._drawer.from_x.setValue(parameters['x_range'][0]) else: self._drawer.from_x.setValue(0) self._drawer.to_x.setValue(maxx) if 'y_range' in parameters: self._drawer.to_y.setValue(parameters['y_range'][1]-1) self._drawer.from_y.setValue(parameters['y_range'][0]) else: self._drawer.from_y.setValue(0) self._drawer.to_y.setValue(maxy) if 'z_range' in parameters: self._drawer.to_z.setValue(parameters['z_range'][1]-1) self._drawer.from_z.setValue(parameters['z_range'][0]) else: self._drawer.from_z.setValue(0) self._drawer.to_z.setValue(maxz) if 'time_range' in parameters: self._drawer.to_time.setValue(parameters['time_range'][1]) self._drawer.from_time.setValue(parameters['time_range'][0]) else: self._drawer.from_time.setValue(0) self._drawer.to_time.setValue(maxt) if 'scales' in parameters: self._drawer.x_scale.setValue(parameters['scales'][0]) self._drawer.y_scale.setValue(parameters['scales'][1]) self._drawer.z_scale.setValue(parameters['scales'][2]) else: self._drawer.x_scale.setValue(1) self._drawer.y_scale.setValue(1) self._drawer.z_scale.setValue(1) return layers
def setupLayers( self ): layers = [] if "MergerOutput" in self.topLevelOperatorView.outputs: ct = colortables.create_default_8bit() for i in range(7): ct[i] = self.mergerColors[i].rgba() if self.topLevelOperatorView.MergerCachedOutput.ready(): self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerCachedOutput ) else: self.mergersrc = LazyflowSource( self.topLevelOperatorView.ZeroOutput ) mergerLayer = ColortableLayer( self.mergersrc, ct ) mergerLayer.name = "Merger" mergerLayer.visible = True layers.append(mergerLayer) ct = colortables.create_random_16bit() ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent ct[1] = QColor(128,128,128,255).rgba() # misdetections have id 1 and will be indicated by grey if self.topLevelOperatorView.CachedOutput.ready(): self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput ) trackingLayer = ColortableLayer( self.trackingsrc, ct ) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) elif self.topLevelOperatorView.zeroProvider.Output.ready(): # provide zeros while waiting for the tracking result self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output ) trackingLayer = ColortableLayer( self.trackingsrc, ct ) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) if self.topLevelOperatorView.LabelImage.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage ) ct = colortables.create_random_16bit() ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent objLayer = ColortableLayer( self.objectssrc, ct ) objLayer.name = "Objects" objLayer.opacity = 1.0 objLayer.visible = True layers.append(objLayer) if self.mainOperator.RawImage.ready(): rawLayer = self.createStandardLayerFromSlot(self.mainOperator.RawImage) rawLayer.name = "Raw" layers.insert( len(layers), rawLayer ) if self.topLevelOperatorView.LabelImage.meta.shape: self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1 maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1 maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1 maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1 if not self.mainOperator.Parameters.ready(): raise Exception("Parameter slot is not ready") parameters = self.mainOperator.Parameters.value self._setRanges() if 'size_range' in parameters: self._drawer.to_size.setValue(parameters['size_range'][1]-1) self._drawer.from_size.setValue(parameters['size_range'][0]) else: self._drawer.from_size.setValue(0) self._drawer.to_size.setValue(10000) if 'x_range' in parameters: self._drawer.to_x.setValue(parameters['x_range'][1]-1) self._drawer.from_x.setValue(parameters['x_range'][0]) else: self._drawer.from_x.setValue(0) self._drawer.to_x.setValue(maxx) if 'y_range' in parameters: self._drawer.to_y.setValue(parameters['y_range'][1]-1) self._drawer.from_y.setValue(parameters['y_range'][0]) else: self._drawer.from_y.setValue(0) self._drawer.to_y.setValue(maxy) if 'z_range' in parameters: self._drawer.to_z.setValue(parameters['z_range'][1]-1) self._drawer.from_z.setValue(parameters['z_range'][0]) else: self._drawer.from_z.setValue(0) self._drawer.to_z.setValue(maxz) if 'time_range' in parameters: self._drawer.to_time.setValue(parameters['time_range'][1]) self._drawer.from_time.setValue(parameters['time_range'][0]) else: self._drawer.from_time.setValue(0) self._drawer.to_time.setValue(maxt) if 'scales' in parameters: self._drawer.x_scale.setValue(parameters['scales'][0]) self._drawer.y_scale.setValue(parameters['scales'][1]) self._drawer.z_scale.setValue(parameters['scales'][2]) else: self._drawer.x_scale.setValue(1) self._drawer.y_scale.setValue(1) self._drawer.z_scale.setValue(1) return layers
def setupLayers(self): layers = [] opLane = self.topLevelOperatorView selection_names = opLane.SelectionNames.value selection = selection_names[opLane.InputSelection.value] # This code depends on a specific order for the export slots. # If those change, update this function! assert selection in [ 'Object Predictions', 'Object Probabilities', 'Pixel Probabilities' ] if selection == "Object Predictions": fromDiskSlot = self.topLevelOperatorView.ImageOnDisk if fromDiskSlot.ready(): exportLayer = ColortableLayer(LazyflowSource(fromDiskSlot), colorTable=self._colorTable16) exportLayer.name = "Prediction - Exported" exportLayer.visible = True layers.append(exportLayer) previewSlot = self.topLevelOperatorView.ImageToExport if previewSlot.ready(): previewLayer = ColortableLayer(LazyflowSource(previewSlot), colorTable=self._colorTable16) previewLayer.name = "Prediction - Preview" previewLayer.visible = False layers.append(previewLayer) elif selection == "Object Probabilities": exportedLayers = self._initPredictionLayers(opLane.ImageOnDisk) for layer in exportedLayers: layer.visible = True layer.name = layer.name + "- Exported" layers += exportedLayers previewLayers = self._initPredictionLayers(opLane.ImageToExport) for layer in previewLayers: layer.visible = False layer.name = layer.name + "- Preview" layers += previewLayers elif selection == 'Pixel Probabilities': exportedLayers = self._initPredictionLayers(opLane.ImageOnDisk) for layer in exportedLayers: layer.visible = True layer.name = layer.name + "- Exported" layers += exportedLayers previewLayers = self._initPredictionLayers(opLane.ImageToExport) for layer in previewLayers: layer.visible = False layer.name = layer.name + "- Preview" layers += previewLayers else: assert False, "Unknown selection." rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw Data" rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): """ Called by our base class when one of our data slots has changed. This function creates a layer for each slot we want displayed in the volume editor. """ # Base class provides the label layer. layers = super(PixelClassificationGui, self).setupLayers() ActionInfo = ShortcutManager.ActionInfo if ilastik_config.getboolean('ilastik', 'debug'): # Add the label projection layer. labelProjectionSlot = self.topLevelOperatorView.opLabelPipeline.opLabelArray.Projection2D if labelProjectionSlot.ready(): projectionSrc = LazyflowSource(labelProjectionSlot) try: # This colortable requires matplotlib from volumina.colortables import jet projectionLayer = ColortableLayer( projectionSrc, colorTable=[QColor(0,0,0,128).rgba()]+jet(N=255), normalize=(0.0, 1.0) ) except (ImportError, RuntimeError): pass else: projectionLayer.name = "Label Projection" projectionLayer.visible = False projectionLayer.opacity = 1.0 layers.append(projectionLayer) # Show the mask over everything except labels maskSlot = self.topLevelOperatorView.PredictionMasks if maskSlot.ready(): maskLayer = self._create_binary_mask_layer_from_slot( maskSlot ) maskLayer.name = "Mask" maskLayer.visible = True maskLayer.opacity = 1.0 layers.append( maskLayer ) # Add the uncertainty estimate layer uncertaintySlot = self.topLevelOperatorView.UncertaintyEstimate if uncertaintySlot.ready(): uncertaintySrc = LazyflowSource(uncertaintySlot) uncertaintyLayer = AlphaModulatedLayer( uncertaintySrc, tintColor=QColor( Qt.cyan ), range=(0.0, 1.0), normalize=(0.0, 1.0) ) uncertaintyLayer.name = "Uncertainty" uncertaintyLayer.visible = False uncertaintyLayer.opacity = 1.0 uncertaintyLayer.shortcutRegistration = ( "u", ActionInfo( "Prediction Layers", "Uncertainty", "Show/Hide Uncertainty", uncertaintyLayer.toggleVisible, self.viewerControlWidget(), uncertaintyLayer ) ) layers.append(uncertaintyLayer) labels = self.labelListData # Add each of the segmentations for channel, segmentationSlot in enumerate(self.topLevelOperatorView.SegmentationChannels): if segmentationSlot.ready() and channel < len(labels): ref_label = labels[channel] segsrc = LazyflowSource(segmentationSlot) segLayer = AlphaModulatedLayer( segsrc, tintColor=ref_label.pmapColor(), range=(0.0, 1.0), normalize=(0.0, 1.0) ) segLayer.opacity = 1 segLayer.visible = False #self.labelingDrawerUi.liveUpdateButton.isChecked() segLayer.visibleChanged.connect(self.updateShowSegmentationCheckbox) def setLayerColor(c, segLayer_=segLayer, initializing=False): if not initializing and segLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return segLayer_.tintColor = c self._update_rendering() def setSegLayerName(n, segLayer_=segLayer, initializing=False): if not initializing and segLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return oldname = segLayer_.name newName = "Segmentation (%s)" % n segLayer_.name = newName if not self.render: return if oldname in self._renderedLayers: label = self._renderedLayers.pop(oldname) self._renderedLayers[newName] = label setSegLayerName(ref_label.name, initializing=True) ref_label.pmapColorChanged.connect(setLayerColor) ref_label.nameChanged.connect(setSegLayerName) #check if layer is 3d before adding the "Toggle 3D" option #this check is done this way to match the VolumeRenderer, in #case different 3d-axistags should be rendered like t-x-y #_axiskeys = segmentationSlot.meta.getAxisKeys() if len(segmentationSlot.meta.shape) == 4: #the Renderer will cut out the last shape-dimension, so #we're checking for 4 dimensions self._setup_contexts(segLayer) layers.append(segLayer) # Add each of the predictions for channel, predictionSlot in enumerate(self.topLevelOperatorView.PredictionProbabilityChannels): if predictionSlot.ready() and channel < len(labels): ref_label = labels[channel] predictsrc = LazyflowSource(predictionSlot) predictLayer = AlphaModulatedLayer( predictsrc, tintColor=ref_label.pmapColor(), range=(0.0, 1.0), normalize=(0.0, 1.0) ) predictLayer.opacity = 0.25 predictLayer.visible = self.labelingDrawerUi.liveUpdateButton.isChecked() predictLayer.visibleChanged.connect(self.updateShowPredictionCheckbox) def setLayerColor(c, predictLayer_=predictLayer, initializing=False): if not initializing and predictLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return predictLayer_.tintColor = c def setPredLayerName(n, predictLayer_=predictLayer, initializing=False): if not initializing and predictLayer_ not in self.layerstack: # This layer has been removed from the layerstack already. # Don't touch it. return newName = "Prediction for %s" % n predictLayer_.name = newName setPredLayerName(ref_label.name, initializing=True) ref_label.pmapColorChanged.connect(setLayerColor) ref_label.nameChanged.connect(setPredLayerName) layers.append(predictLayer) # Add the raw data last (on the bottom) inputDataSlot = self.topLevelOperatorView.InputImages if inputDataSlot.ready(): inputLayer = self.createStandardLayerFromSlot( inputDataSlot ) inputLayer.name = "Input Data" inputLayer.visible = True inputLayer.opacity = 1.0 # the flag window_leveling is used to determine if the contrast # of the layer is adjustable if isinstance( inputLayer, GrayscaleLayer ): inputLayer.window_leveling = True else: inputLayer.window_leveling = False def toggleTopToBottom(): index = self.layerstack.layerIndex( inputLayer ) self.layerstack.selectRow( index ) if index == 0: self.layerstack.moveSelectedToBottom() else: self.layerstack.moveSelectedToTop() inputLayer.shortcutRegistration = ( "i", ActionInfo( "Prediction Layers", "Bring Input To Top/Bottom", "Bring Input To Top/Bottom", toggleTopToBottom, self.viewerControlWidget(), inputLayer ) ) layers.append(inputLayer) # The thresholding button can only be used if the data is displayed as grayscale. if inputLayer.window_leveling: self.labelingDrawerUi.thresToolButton.show() else: self.labelingDrawerUi.thresToolButton.hide() self.handleLabelSelectionChange() return layers
def setupLayers(self): layers = super(Counting3dGui, self).setupLayers() from PyQt4.QtGui import QColor # Base class provides the label layer. #layers = super(Counting3dGui, self).setupLayers() #This is just for colors #labels = self.labelListData #Personal Note: the standardlayer rescales its value range when #displaying gray value images, which, in turn, makes some data invisible #when being viewed after some others. #labelOutput = self._labelingSlots.labelOutput slots = {#'featureData' : self.op.FeatureData, #'filteredFeatureData' : self.op.FilteredFeatureData, #'modFeatureData' : self.op.ModifiedFeatureData, 'density' : self.op.Density #'FilteredRawData' : self.op.FilteredRaw } colortableSlots = { 'UserLabels' : self.op.LabelImages } for name, slot in colortableSlots.items(): if slot.ready(): self.imagesrc = LazyflowSource(slot) ct = colortables.default16 ct[0] = QColor(0,0,0,0) layer = ColortableLayer(self.imagesrc, colorTable = colortables.default16) layer.zeroIsTransparent= True layer.name = name layers.append(layer) for name, slot in slots.items(): if slot.ready(): self.imagesrc = LazyflowSource(slot) layer = self.createStandardLayerFromSlot(slot) layer.name = name layers.append(layer) #if binarySlot.ready(): # ct_binary = [QColor(0,0,0,0).rgba(), QColor(0,0,255,255).rgba()] # self.binaryimagesrc = LazyflowSource(binarySlot) # #layer = GrayscaleLayer(self.binaryimagesrc, range=(0,1), normalize=(0,1)) # layer = ColortableLayer(self.binaryimagesrc, ct_binary) # layer.name = "Binary Image" # layers.append(layer) #predictionSlot = self.op.PredictionImages #if predictionSlot.ready(): # self.predictsrc = LazyflowSource(predictionSlot) # self.predictlayer = ColortableLayer(self.predictsrc, colorTable=self._colorTable16) # self.predictlayer.name = "Prediction" # self.predictlayer.ref_object = None # self.predictlayer.visible = self.labelingDrawerUi.checkInteractive.isChecked() # # put first, so that it is visible after hitting "live # # predict". # layers.insert(0, self.predictlayer) return layers
def setupLayers(self): layers = [] opLane = self.topLevelOperatorView selection_names = opLane.SelectionNames.value selection = selection_names[ opLane.InputSelection.value ] # This code depends on a specific order for the export slots. # If those change, update this function! assert selection in ['Object Predictions', 'Object Probabilities', 'Pixel Probabilities'] if selection == "Object Predictions": fromDiskSlot = self.topLevelOperatorView.ImageOnDisk if fromDiskSlot.ready(): exportLayer = ColortableLayer( LazyflowSource(fromDiskSlot), colorTable=self._colorTable16 ) exportLayer.name = "Prediction - Exported" exportLayer.visible = True layers.append(exportLayer) previewSlot = self.topLevelOperatorView.ImageToExport if previewSlot.ready(): previewLayer = ColortableLayer( LazyflowSource(previewSlot), colorTable=self._colorTable16 ) previewLayer.name = "Prediction - Preview" previewLayer.visible = False layers.append(previewLayer) elif selection == "Object Probabilities": exportedLayers = self._initPredictionLayers(opLane.ImageOnDisk) for layer in exportedLayers: layer.visible = True layer.name = layer.name + "- Exported" layers += exportedLayers previewLayers = self._initPredictionLayers(opLane.ImageToExport) for layer in previewLayers: layer.visible = False layer.name = layer.name + "- Preview" layers += previewLayers elif selection == 'Pixel Probabilities': exportedLayers = self._initPredictionLayers(opLane.ImageOnDisk) for layer in exportedLayers: layer.visible = True layer.name = layer.name + "- Exported" layers += exportedLayers previewLayers = self._initPredictionLayers(opLane.ImageToExport) for layer in previewLayers: layer.visible = False layer.name = layer.name + "- Preview" layers += previewLayers else: assert False, "Unknown selection." rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw Data" rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): mainOperator = self.topLevelOperatorView layers = [] if mainOperator.ObjectCenterImage.ready(): self.centerimagesrc = LazyflowSource(mainOperator.ObjectCenterImage) redct = [0, QColor(255, 0, 0).rgba()] layer = ColortableLayer(self.centerimagesrc, redct) layer.name = "Object centers" layer.setToolTip("Object center positions, marked with a little red cross") layer.visible = False layers.append(layer) ct = colortables.create_default_16bit() if mainOperator.LabelImage.ready(): self.objectssrc = LazyflowSource(mainOperator.LabelImage) self.objectssrc.setObjectName("LabelImage LazyflowSrc") ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent layer = ColortableLayer(self.objectssrc, ct) layer.name = "Objects (connected components)" layer.setToolTip("Segmented objects, shown in different colors") layer.visible = False layer.opacity = 0.5 layers.append(layer) # white foreground on transparent background, even for labeled images binct = [QColor(255, 255, 255, 255).rgba()]*65536 binct[0] = 0 if mainOperator.BinaryImage.ready(): self.binaryimagesrc = LazyflowSource(mainOperator.BinaryImage) self.binaryimagesrc.setObjectName("Binary LazyflowSrc") layer = ColortableLayer(self.binaryimagesrc, binct) layer.name = "Binary image" layer.setToolTip("Segmented objects, binary mask") layers.append(layer) ## raw data layer self.rawsrc = None self.rawsrc = LazyflowSource(mainOperator.RawImage) self.rawsrc.setObjectName("Raw Lazyflow Src") layerraw = GrayscaleLayer(self.rawsrc) layerraw.name = "Raw data" layers.insert(len(layers), layerraw) mainOperator.RawImage.notifyReady(self._onReady) self.__cleanup_fns.append( partial( mainOperator.RawImage.unregisterReady, self._onReady ) ) mainOperator.RawImage.notifyMetaChanged(self._onMetaChanged) self.__cleanup_fns.append( partial( mainOperator.RawImage.unregisterMetaChanged, self._onMetaChanged ) ) if mainOperator.BinaryImage.meta.shape: self.editor.dataShape = mainOperator.BinaryImage.meta.shape mainOperator.BinaryImage.notifyMetaChanged(self._onMetaChanged) self.__cleanup_fns.append( partial( mainOperator.BinaryImage.unregisterMetaChanged, self._onMetaChanged ) ) return layers
def setupLayers(self): mainOperator = self.topLevelOperatorView layers = [] if mainOperator.ObjectCenterImage.ready(): self.centerimagesrc = LazyflowSource( mainOperator.ObjectCenterImage) redct = [0, QColor(255, 0, 0).rgba()] layer = ColortableLayer(self.centerimagesrc, redct) layer.name = "Object centers" layer.setToolTip( "Object center positions, marked with a little red cross") layer.visible = False layers.append(layer) ct = colortables.create_default_16bit() if mainOperator.LabelImage.ready(): self.objectssrc = LazyflowSource(mainOperator.LabelImage) self.objectssrc.setObjectName("LabelImage LazyflowSrc") ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent layer = ColortableLayer(self.objectssrc, ct) layer.name = "Objects (connected components)" layer.setToolTip("Segmented objects, shown in different colors") layer.visible = False layer.opacity = 0.5 layers.append(layer) # white foreground on transparent background, even for labeled images binct = [QColor(255, 255, 255, 255).rgba()] * 65536 binct[0] = 0 if mainOperator.BinaryImage.ready(): self.binaryimagesrc = LazyflowSource(mainOperator.BinaryImage) self.binaryimagesrc.setObjectName("Binary LazyflowSrc") layer = ColortableLayer(self.binaryimagesrc, binct) layer.name = "Binary image" layer.setToolTip("Segmented objects, binary mask") layers.append(layer) ## raw data layer self.rawsrc = None self.rawsrc = LazyflowSource(mainOperator.RawImage) self.rawsrc.setObjectName("Raw Lazyflow Src") layerraw = GrayscaleLayer(self.rawsrc) layerraw.name = "Raw data" layers.insert(len(layers), layerraw) mainOperator.RawImage.notifyReady(self._onReady) self.__cleanup_fns.append( partial(mainOperator.RawImage.unregisterReady, self._onReady)) mainOperator.RawImage.notifyMetaChanged(self._onMetaChanged) self.__cleanup_fns.append( partial(mainOperator.RawImage.unregisterMetaChanged, self._onMetaChanged)) mainOperator.BinaryImage.notifyMetaChanged(self._onMetaChanged) self.__cleanup_fns.append( partial(mainOperator.BinaryImage.unregisterMetaChanged, self._onMetaChanged)) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] binct[0] = 0 ct = create_default_16bit() ct[0] = 0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, ct) outputLayer.name = "Final output" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of thresholding and size filter") layers.append(outputLayer) if op.InputChannelColors.ready(): input_channel_colors = [QColor(r_g_b1[0],r_g_b1[1],r_g_b1[2]) for r_g_b1 in op.InputChannelColors.value] else: input_channel_colors = list(map(QColor, self._defaultInputChannelColors)) for channel, channelProvider in enumerate(self._channelProviders): slot_drange = channelProvider.Output.meta.drange if slot_drange is not None: drange = slot_drange else: drange = (0.0, 1.0) channelSrc = LazyflowSource(channelProvider.Output) inputChannelLayer = AlphaModulatedLayer( channelSrc, tintColor=input_channel_colors[channel], range=drange, normalize=drange) inputChannelLayer.opacity = 0.5 inputChannelLayer.visible = True inputChannelLayer.name = "Input Channel " + str(channel) inputChannelLayer.setToolTip("Select input channel " + str(channel) + \ " if this prediction image contains the objects of interest.") layers.append(inputChannelLayer) if self._showDebug: #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = op.CurOperator.value if curIndex==1: if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer(lowThresholdSrc, binct) lowThresholdLayer.name = "After low threshold" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 lowThresholdLayer.setToolTip("Results of thresholding with the low pixel value threshold") layers.append(lowThresholdLayer) if op.FilteredSmallLabels.ready(): filteredSmallLabelsSrc = LazyflowSource(op.FilteredSmallLabels) #filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels ) filteredSmallLabelsLayer = ColortableLayer(filteredSmallLabelsSrc, binct) filteredSmallLabelsLayer.name = "After high threshold and size filter" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 filteredSmallLabelsLayer.setToolTip("Results of thresholding with the high pixel value threshold,\ followed by the size filter") layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer(highThresholdSrc, binct) highThresholdLayer.name = "After high threshold" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 highThresholdLayer.setToolTip("Results of thresholding with the high pixel value threshold") layers.append(highThresholdLayer) elif curIndex==0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer(thSrc, ct) thLayer.name = "Before size filter" thLayer.visible = False thLayer.opacity = 1.0 thLayer.setToolTip("Results of thresholding before the size filter is applied") layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot( op.Smoothed ) smoothedLayer.name = "Smoothed input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 smoothedLayer.setToolTip("Selected channel data, smoothed with a Gaussian with user-defined sigma") layers.append(smoothedLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot( rawSlot ) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] # use same colortable for the following two generated layers: the merger # and the tracking layer self.tracking_colortable = colortables.create_random_16bit() self.tracking_colortable[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent self.tracking_colortable[1] = QColor(128, 128, 128, 255).rgba( ) # misdetections have id 1 and will be indicated by grey self.merger_colortable = colortables.create_default_16bit() for i in range(7): self.merger_colortable[i] = self.mergerColors[i].rgba() if "MergerOutput" in self.topLevelOperatorView.outputs: parameters = self.mainOperator.Parameters.value if 'withMergerResolution' in list(parameters.keys( )) and not parameters['withMergerResolution']: merger_ct = self.merger_colortable else: merger_ct = self.tracking_colortable # Using same color table for tracking with and without mergers (Is there any reason for using different color tables?) merger_ct = self.tracking_colortable if self.topLevelOperatorView.MergerCachedOutput.ready(): self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerCachedOutput) else: self.mergersrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output) mergerLayer = ColortableLayer(self.mergersrc, merger_ct) mergerLayer.name = "Merger" if 'withMergerResolution' in list(parameters.keys( )) and not parameters['withMergerResolution']: mergerLayer.visible = True else: mergerLayer.visible = False layers.append(mergerLayer) if self.topLevelOperatorView.CachedOutput.ready(): self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput) trackingLayer = ColortableLayer(self.trackingsrc, self.tracking_colortable) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) elif self.topLevelOperatorView.zeroProvider.Output.ready(): # provide zeros while waiting for the tracking result self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output) trackingLayer = ColortableLayer(self.trackingsrc, self.tracking_colortable) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) if "RelabeledImage" in self.topLevelOperatorView.outputs: if self.topLevelOperatorView.RelabeledCachedOutput.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.RelabeledCachedOutput) else: self.objectssrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output) else: if self.topLevelOperatorView.LabelImage.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage) ct = colortables.create_random_16bit() ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent objLayer = ColortableLayer(self.objectssrc, ct) objLayer.name = "Objects" objLayer.opacity = 1.0 objLayer.visible = False layers.append(objLayer) if self.mainOperator.RawImage.ready(): rawLayer = self.createStandardLayerFromSlot( self.mainOperator.RawImage) rawLayer.name = "Raw" layers.insert(len(layers), rawLayer) if self.topLevelOperatorView.LabelImage.meta.shape: maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1 maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1 maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1 maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1 if not self.mainOperator.Parameters.ready(): raise Exception("Parameter slot is not ready") parameters = self.mainOperator.Parameters.value self._setRanges() if 'size_range' in parameters: self._drawer.to_size.setValue(parameters['size_range'][1] - 1) self._drawer.from_size.setValue(parameters['size_range'][0]) else: self._drawer.from_size.setValue(0) self._drawer.to_size.setValue(10000) if 'x_range' in parameters: self._drawer.to_x.setValue(parameters['x_range'][1] - 1) self._drawer.from_x.setValue(parameters['x_range'][0]) else: self._drawer.from_x.setValue(0) self._drawer.to_x.setValue(maxx) if 'y_range' in parameters: self._drawer.to_y.setValue(parameters['y_range'][1] - 1) self._drawer.from_y.setValue(parameters['y_range'][0]) else: self._drawer.from_y.setValue(0) self._drawer.to_y.setValue(maxy) if 'z_range' in parameters: self._drawer.to_z.setValue(parameters['z_range'][1] - 1) self._drawer.from_z.setValue(parameters['z_range'][0]) else: self._drawer.from_z.setValue(0) self._drawer.to_z.setValue(maxz) if 'time_range' in parameters: self._drawer.to_time.setValue(parameters['time_range'][1]) self._drawer.from_time.setValue(parameters['time_range'][0]) else: self._drawer.from_time.setValue(0) self._drawer.to_time.setValue(maxt) if 'scales' in parameters: self._drawer.x_scale.setValue(parameters['scales'][0]) self._drawer.y_scale.setValue(parameters['scales'][1]) self._drawer.z_scale.setValue(parameters['scales'][2]) else: self._drawer.x_scale.setValue(1) self._drawer.y_scale.setValue(1) self._drawer.z_scale.setValue(1) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] ct = self._createDefault16ColorColorTable() ct[0]=0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, binct) outputLayer.name = "Output (Cached)" outputLayer.visible = False outputLayer.opacity = 1.0 layers.append(outputLayer) #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = self._drawer.tabWidget.currentIndex() if curIndex==1: if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer(lowThresholdSrc, binct) lowThresholdLayer.name = "Big Regions" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 layers.append(lowThresholdLayer) if op.FilteredSmallLabels.ready(): filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels ) filteredSmallLabelsLayer.name = "Filtered Small Labels" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer(highThresholdSrc, binct) highThresholdLayer.name = "Small Regions" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 layers.append(highThresholdLayer) elif curIndex==0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer(thSrc, binct) thLayer.name = "Thresholded Labels" thLayer.visible = False thLayer.opacity = 1.0 layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot( op.Smoothed ) smoothedLayer.name = "Smoothed Input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 layers.append(smoothedLayer) # Show the selected channel if op.InputChannel.ready(): drange = op.InputChannel.meta.drange if drange is None: drange = (0.0, 1.0) channelSrc = LazyflowSource(op.InputChannel) channelLayer = AlphaModulatedLayer( channelSrc, tintColor=QColor(self._channelColors[op.Channel.value]), range=drange, normalize=drange ) channelLayer.name = "Input Ch{}".format(op.Channel.value) channelLayer.opacity = 1.0 #channelLayer.visible = channelIndex == op.Channel.value # By default, only the selected input channel is visible. layers.append(channelLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot( rawSlot ) rawLayer.name = "Raw Data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] binct[0] = 0 ct = self._createDefault16ColorColorTable() ct[0] = 0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, binct) outputLayer.name = "Final output" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of thresholding and size filter") layers.append(outputLayer) if self._showDebug: #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = self._drawer.tabWidget.currentIndex() if curIndex == 1: if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer(lowThresholdSrc, binct) lowThresholdLayer.name = "After low threshold" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 lowThresholdLayer.setToolTip( "Results of thresholding with the low pixel value threshold" ) layers.append(lowThresholdLayer) if op.FilteredSmallLabels.ready(): filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels) filteredSmallLabelsLayer.name = "After high threshold and size filter" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 filteredSmallLabelsLayer.setToolTip( "Results of thresholding with the high pixel value threshold,\ followed by the size filter" ) layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer( highThresholdSrc, binct) highThresholdLayer.name = "After high threshold" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 highThresholdLayer.setToolTip( "Results of thresholding with the high pixel value threshold" ) layers.append(highThresholdLayer) elif curIndex == 0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer(thSrc, ct) thLayer.name = "Before size filter" thLayer.visible = False thLayer.opacity = 1.0 thLayer.setToolTip( "Results of thresholding before the size filter is applied" ) layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot(op.Smoothed) smoothedLayer.name = "Smoothed input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 smoothedLayer.setToolTip( "Selected channel data, smoothed with a Gaussian with user-defined sigma" ) layers.append(smoothedLayer) # Show the selected channel if op.InputChannel.ready(): drange = op.InputChannel.meta.drange if drange is None: drange = (0.0, 1.0) channelSrc = LazyflowSource(op.InputChannel) #channelLayer = AlphaModulatedLayer( channelSrc, # tintColor=QColor(self._channelColors[op.Channel.value]), # range=drange, # normalize=drange ) #it used to be set to the label color, but people found it confusing channelLayer = AlphaModulatedLayer(channelSrc, tintColor=QColor(Qt.white), range=drange, normalize=drange) channelLayer.name = "Selected input channel" channelLayer.opacity = 1.0 channelLayer.setToolTip( "The selected channel of the prediction images") #channelLayer.visible = channelIndex == op.Channel.value # By default, only the selected input channel is visible. layers.append(channelLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView ct = create_default_16bit() ct[0] = 0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, ct) outputLayer.name = "Final output" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of thresholding and size filter") layers.append(outputLayer) if op.InputChannelColors.ready(): input_channel_colors = [ QColor(r_g_b1[0], r_g_b1[1], r_g_b1[2]) for r_g_b1 in op.InputChannelColors.value ] else: input_channel_colors = list( map(QColor, self._defaultInputChannelColors)) for channel, channelProvider in enumerate(self._channelProviders): slot_drange = channelProvider.Output.meta.drange if slot_drange is not None: drange = slot_drange else: drange = (0.0, 1.0) channelSrc = LazyflowSource(channelProvider.Output) inputChannelLayer = AlphaModulatedLayer( channelSrc, tintColor=input_channel_colors[channel], range=drange, normalize=drange) inputChannelLayer.opacity = 0.5 inputChannelLayer.visible = True inputChannelLayer.name = "Input Channel " + str(channel) inputChannelLayer.setToolTip("Select input channel " + str(channel) + \ " if this prediction image contains the objects of interest.") layers.append(inputChannelLayer) if self._showDebug: #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = op.CurOperator.value if curIndex in (1, 3): if op.FilteredSmallLabels.ready(): filteredSmallLabelsSrc = LazyflowSource( op.FilteredSmallLabels) #filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels ) filteredSmallLabelsLayer = ColortableLayer( filteredSmallLabelsSrc, DebugLayerCmap.BINARY_SHADE_1.value) filteredSmallLabelsLayer.name = "After high threshold and size filter" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 filteredSmallLabelsLayer.setToolTip( "Results of thresholding with the high pixel value threshold,\ followed by the size filter" ) layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer( highThresholdSrc, DebugLayerCmap.BINARY_SHADE_0.value) highThresholdLayer.name = "After high threshold" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 highThresholdLayer.setToolTip( "Results of thresholding with the high pixel value threshold" ) layers.append(highThresholdLayer) if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer( lowThresholdSrc, DebugLayerCmap.BINARY_WHITE.value) lowThresholdLayer.name = "After low threshold" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 lowThresholdLayer.setToolTip( "Results of thresholding with the low pixel value threshold" ) layers.append(lowThresholdLayer) elif curIndex == 0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer( thSrc, DebugLayerCmap.BINARY_WHITE.value) thLayer.name = "Before size filter" thLayer.visible = False thLayer.opacity = 1.0 thLayer.setToolTip( "Results of thresholding before the size filter is applied" ) layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot(op.Smoothed) smoothedLayer.name = "Smoothed input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 smoothedLayer.setToolTip( "Selected channel data, smoothed with a Gaussian with user-defined sigma" ) layers.append(smoothedLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot(rawSlot) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView binct = [QColor(Qt.black), QColor(Qt.white)] binct[0] = 0 ct = create_default_16bit() ct[0] = 0 # Show the cached output, since it goes through a blocked cache if op.CachedOutput.ready(): outputSrc = LazyflowSource(op.CachedOutput) outputLayer = ColortableLayer(outputSrc, ct) outputLayer.name = "Final output" outputLayer.visible = False outputLayer.opacity = 1.0 outputLayer.setToolTip("Results of thresholding and size filter") layers.append(outputLayer) for channel, channelProvider in enumerate(self._channelProviders): channelSrc = LazyflowSource(channelProvider.Output) inputChannelLayer = AlphaModulatedLayer( channelSrc, tintColor=QColor(self._channelColors[channel]), range=(0.0, 1.0), normalize=(0.0, 1.0)) inputChannelLayer.opacity = 0.5 inputChannelLayer.visible = True inputChannelLayer.name = "Input Channel " + str(channel) inputChannelLayer.setToolTip("Select input channel " + str(channel) + \ " if this prediction image contains the objects of interest.") layers.append(inputChannelLayer) if self._showDebug: #FIXME: We have to do that, because lazyflow doesn't have a way to make an operator partially ready curIndex = self._drawer.tabWidget.currentIndex() if curIndex==1: if op.BigRegions.ready(): lowThresholdSrc = LazyflowSource(op.BigRegions) lowThresholdLayer = ColortableLayer(lowThresholdSrc, binct) lowThresholdLayer.name = "After low threshold" lowThresholdLayer.visible = False lowThresholdLayer.opacity = 1.0 lowThresholdLayer.setToolTip("Results of thresholding with the low pixel value threshold") layers.append(lowThresholdLayer) if op.FilteredSmallLabels.ready(): filteredSmallLabelsSrc = LazyflowSource(op.FilteredSmallLabels) #filteredSmallLabelsLayer = self.createStandardLayerFromSlot( op.FilteredSmallLabels ) filteredSmallLabelsLayer = ColortableLayer(filteredSmallLabelsSrc, binct) filteredSmallLabelsLayer.name = "After high threshold and size filter" filteredSmallLabelsLayer.visible = False filteredSmallLabelsLayer.opacity = 1.0 filteredSmallLabelsLayer.setToolTip("Results of thresholding with the high pixel value threshold,\ followed by the size filter") layers.append(filteredSmallLabelsLayer) if op.SmallRegions.ready(): highThresholdSrc = LazyflowSource(op.SmallRegions) highThresholdLayer = ColortableLayer(highThresholdSrc, binct) highThresholdLayer.name = "After high threshold" highThresholdLayer.visible = False highThresholdLayer.opacity = 1.0 highThresholdLayer.setToolTip("Results of thresholding with the high pixel value threshold") layers.append(highThresholdLayer) elif curIndex==0: if op.BeforeSizeFilter.ready(): thSrc = LazyflowSource(op.BeforeSizeFilter) thLayer = ColortableLayer(thSrc, ct) thLayer.name = "Before size filter" thLayer.visible = False thLayer.opacity = 1.0 thLayer.setToolTip("Results of thresholding before the size filter is applied") layers.append(thLayer) # Selected input channel, smoothed. if op.Smoothed.ready(): smoothedLayer = self.createStandardLayerFromSlot( op.Smoothed ) smoothedLayer.name = "Smoothed input" smoothedLayer.visible = True smoothedLayer.opacity = 1.0 smoothedLayer.setToolTip("Selected channel data, smoothed with a Gaussian with user-defined sigma") layers.append(smoothedLayer) # Show the raw input data rawSlot = self.topLevelOperatorView.RawInput if rawSlot.ready(): rawLayer = self.createStandardLayerFromSlot( rawSlot ) rawLayer.name = "Raw data" rawLayer.visible = True rawLayer.opacity = 1.0 layers.append(rawLayer) return layers