def test_Incomplete_graph( self ):
g = Graph()
opMunch = OpMuncher( graph = g )
ls = LazyflowSource(opMunch.Output)
res = ls.request((slice(1, 2, None),)).wait()
assert res.shape == (1,)
assert res[0] == 0
def setupLayers(self):
layers = []
op = self.topLevelOperatorView
# Superpixels
if op.Superpixels.ready():
layer = ColortableLayer( LazyflowSource(op.Superpixels), self._sp_colortable )
layer.colortableIsRandom = True
layer.name = "Superpixels"
layer.visible = True
layer.opacity = 0.5
layers.append(layer)
del layer
# Debug layers
if op.debug_results:
for name, compressed_array in op.debug_results.items():
axiskeys = op.Superpixels.meta.getAxisKeys()[:-1] # debug images don't have a channel axis
permutation = map(lambda key: axiskeys.index(key) if key in axiskeys else None, 'txyzc')
arraysource = ArraySource( TransposedView(compressed_array, permutation) )
if compressed_array.dtype == np.uint32:
layer = ColortableLayer(arraysource, self._sp_colortable)
else:
layer = GrayscaleLayer(arraysource)
# TODO: Normalize? Maybe the drange should be included with the debug image.
layer.name = name
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
# Threshold
if op.ThresholdedInput.ready():
layer = ColortableLayer( LazyflowSource(op.ThresholdedInput), self._threshold_colortable )
layer.name = "Thresholded Input"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.Input.ready():
layer = self._create_grayscale_layer_from_slot( op.Input, op.Input.meta.getTaggedShape()['c'] )
layer.name = "Input"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.RawData.ready():
layer = self.createStandardLayerFromSlot( op.RawData )
layer.name = "Raw Data"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
del layer
return layers
def setupLayers(self):
layers = []
op = self.__topLevelOperatorView
mc_edge_layer = self.create_multicut_edge_layer()
if mc_edge_layer:
layers.append(mc_edge_layer)
# Superpixels -- Edge Probabilities
# We use the RAG's superpixels, which may have different IDs
self.superpixel_edge_layer = None
if op.Superpixels.ready() and op.EdgeProbabilitiesDict.ready():
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels))
layer.name = "Superpixel Edge Probabilities"
layer.visible = True
layer.opacity = 1.0
self.superpixel_edge_layer = layer
self.__update_probability_edges() # Initialize
layers.append(layer)
del layer
# Superpixels -- Edges
if op.Superpixels.ready():
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.yellow)
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels),
default_pen)
layer.name = "Superpixel Edges"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
mc_seg_layer = self.create_multicut_segmentation_layer()
if mc_seg_layer:
layers.append(mc_seg_layer)
# Superpixels
if op.Superpixels.ready():
layer = self.createStandardLayerFromSlot(op.Superpixels)
layer.name = "Superpixels"
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.RawData.ready():
layer = self.createStandardLayerFromSlot(op.RawData)
layer.name = "Raw Data"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
del layer
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):
"""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 = []
opLane = self.topLevelOperatorView
# Supervoxels
watershedSlot = opLane.WatershedImage
if watershedSlot.ready():
colortable = []
for i in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
watershedLayer = ColortableLayer(LazyflowSource(watershedSlot),
colortable)
watershedLayer.name = "Watershed"
watershedLayer.visible = False
watershedLayer.opacity = 0.5
watershedLayer.colortableIsRandom = True
layers.append(watershedLayer)
''' FIXME: disabled for 0.6 release
wsSourceSlot = opLane.WatershedSourceImage
if wsSourceSlot.ready():
wsSourceLayer = self.createStandardLayerFromSlot( wsSourceSlot )
wsSourceLayer.name = "Watershed Source"
wsSourceLayer.visible = False
wsSourceLayer.opacity = 1.0
layers.append( wsSourceLayer )
'''
filteredSlot = opLane.FilteredImage
if filteredSlot.ready():
filteredLayer = self.createStandardLayerFromSlot(filteredSlot)
filteredLayer.name = "Filtered Data"
filteredLayer.visible = False
filteredLayer.opacity = 1.0
layers.append(filteredLayer)
overlaySlot = opLane.OverlayData
if overlaySlot.ready():
inputLayer = self.createStandardLayerFromSlot(overlaySlot)
inputLayer.name = "Overlay Image"
inputLayer.visible = False
inputLayer.opacity = 1.0
layers.append(inputLayer)
inputSlot = opLane.InputData
if inputSlot.ready():
inputLayer = self.createStandardLayerFromSlot(inputSlot)
inputLayer.name = "Input Data"
inputLayer.visible = True
inputLayer.opacity = 1.0
layers.append(inputLayer)
return layers
def addFragmentSegmentationLayers(mslot, name):
if mslot.ready():
for index, slot in enumerate(mslot):
if slot.ready():
raveler_label = slot.meta.selected_label
colortable = map(QColor.rgba, self._fragmentColors)
fragSegLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True)
fragSegLayer.name = "{} #{} ({})".format( name, index, raveler_label )
fragSegLayer.visible = False
fragSegLayer.opacity = 1.0
layers.append(fragSegLayer)
def initUic(self):
self.g = g = Graph()
#get the absolute path of the 'ilastik' module
uic.loadUi("designerElements/MainWindow.ui", self)
self.actionQuit.triggered.connect(qApp.quit)
def toggleDebugPatches(show):
self.editor.showDebugPatches = show
self.actionShowDebugPatches.toggled.connect(toggleDebugPatches)
self.layerstack = LayerStackModel()
readerNew = op.OpH5ReaderBigDataset(g)
readerNew.inputs["Filenames"].setValue([
"scripts/CB_compressed_XY.h5", "scripts/CB_compressed_XZ.h5",
"scripts/CB_compressed_YZ.h5"
])
readerNew.inputs["hdf5Path"].setValue("volume/data")
datasrc = LazyflowSource(readerNew.outputs["Output"])
layer1 = GrayscaleLayer(datasrc)
layer1.name = "Big Data"
self.layerstack.append(layer1)
shape = readerNew.outputs["Output"].meta.shape
print shape
self.editor = VolumeEditor(shape, self.layerstack)
#self.editor.setDrawingEnabled(False)
self.volumeEditorWidget.init(self.editor)
model = self.editor.layerStack
self.layerWidget.init(model)
self.UpButton.clicked.connect(model.moveSelectedUp)
model.canMoveSelectedUp.connect(self.UpButton.setEnabled)
self.DownButton.clicked.connect(model.moveSelectedDown)
model.canMoveSelectedDown.connect(self.DownButton.setEnabled)
self.DeleteButton.clicked.connect(model.deleteSelected)
model.canDeleteSelected.connect(self.DeleteButton.setEnabled)
def setUp(self):
self.layerstack = LayerStackModel()
self.sims = StackedImageSources(self.layerstack)
self.g = Graph()
self.op = OpLazy(self.g)
self.ds = LazyflowSource(self.op.Output)
self.ss = SliceSource(self.ds, projectionAlongTZC)
self.layer = GrayscaleLayer(self.ds, normalize=False)
self.layerstack.append(self.layer)
self.ims = imsfac.createImageSource(self.layer, [self.ss])
self.sims.register(self.layer, self.ims)
self.scene = ImageScene2D(PositionModel(), (0, 0, 0), preemptive_fetch_number=0)
self.scene.setCacheSize(1)
self.scene.stackedImageSources = self.sims
self.scene.dataShape = (30, 30)
def addFragmentSegmentationLayers(mslot, name):
if mslot.ready():
for index, slot in enumerate(mslot):
if slot.ready():
raveler_label = slot.meta.selected_label
colortable = []
for i in range(256):
r, g, b = numpy.random.randint(
0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
colortable[0] = QColor(0, 0, 0, 0).rgba()
fragSegLayer = ColortableLayer(LazyflowSource(slot),
colortable,
direct=True)
fragSegLayer.name = "{} #{} ({})".format(
name, index, raveler_label)
fragSegLayer.visible = False
fragSegLayer.opacity = 1.0
layers.append(fragSegLayer)
def create_multicut_edge_layer(self):
ActionInfo = ShortcutManager.ActionInfo
op = self.__topLevelOperatorView
if not op.Output.ready():
return None
# Final segmentation -- Edges
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.blue)
layer = SegmentationEdgesLayer(LazyflowSource(op.Output), default_pen)
layer.name = "Multicut Edges"
layer.visible = False # Off by default...
layer.opacity = 1.0
layer.shortcutRegistration = ("m",
ActionInfo("Multicut",
"MulticutEdgesVisibility",
"Show/Hide Multicut Edges",
layer.toggleVisible,
self.viewerControlWidget(),
layer))
return layer
def create_multicut_disagreement_layer(self):
ActionInfo = ShortcutManager.ActionInfo
op = self.__topLevelOperatorView
if not op.Output.ready():
return None
# Final segmentation -- Edges
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.transparent)
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels),
default_pen)
layer.name = "Multicut Disagreements"
layer.visible = False # Off by default...
layer.opacity = 1.0
self.disagreement_layer = layer
self.__update_disagreement_edges() # Initialize
layer.shortcutRegistration = (
"d",
ActionInfo("Multicut", "MulticutDisagrementVisibility",
"Show/Hide Multicut Disagreement Edges",
layer.toggleVisible, self.viewerControlWidget(), layer))
return layer
def do():
#Generate
#array[:] = np.random.randint(0,255,500*500).reshape(shape).astype(np.uint8)
a = np.zeros(500 * 500).reshape(500, 500).astype(np.uint8)
ii = np.random.randint(0, 500, 1)
jj = np.random.randint(0, 500, 1)
a[ii, jj] = 1
a = vigra.filters.discDilation(a, radius=20)
array[:] = a.reshape(shape).view(np.ndarray) * 255
op.Input.setDirty()
do()
cron.timeout.connect(do)
ds = LazyflowSource(op.Output)
layer = ColortableLayer(ds, jet())
mainwin = Viewer()
mainwin.layerstack.append(layer)
mainwin.dataShape = (1, h, w, 1, 1)
print(mainwin.centralWidget())
BoxContr = BoxController(mainwin.editor, op.Output, boxListModel)
BoxInt = BoxInterpreter(mainwin.editor.navInterpret,
mainwin.editor.posModel, BoxContr,
mainwin.centralWidget())
mainwin.editor.setNavigationInterpreter(BoxInt)
# boxListModel.boxRemoved.connect(BoxContr.deleteItem)
def setupLayers(self):
layers = []
op = self.__topLevelOperatorView
mc_disagreement_layer = self.create_multicut_disagreement_layer()
if mc_disagreement_layer:
layers.append(mc_disagreement_layer)
mc_edge_layer = self.create_multicut_edge_layer()
if mc_edge_layer:
layers.append(mc_edge_layer)
# Superpixels -- Edge Probabilities
# We use the RAG's superpixels, which may have different IDs
self.superpixel_edge_layer = None
if op.Superpixels.ready() and op.EdgeProbabilitiesDict.ready():
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels))
layer.name = "Superpixel Edge Probabilities"
layer.visible = True
layer.opacity = 1.0
self.superpixel_edge_layer = layer
self.__update_probability_edges() # Initialize
layers.append(layer)
del layer
# Superpixels -- Edges
if op.Superpixels.ready():
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.yellow)
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels),
default_pen)
layer.name = "Superpixel Edges"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
mc_seg_layer = self.create_multicut_segmentation_layer()
if mc_seg_layer:
layers.append(mc_seg_layer)
# Superpixels
if op.Superpixels.ready():
layer = self.createStandardLayerFromSlot(op.Superpixels)
layer.name = "Superpixels"
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.RawData.ready():
layer = self.createStandardLayerFromSlot(op.RawData)
layer.name = "Raw Data"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
layer.shortcutRegistration = ("i",
ActionInfo(
"Multicut"
"Hide all but Raw",
"Hide all but Raw",
partial(self.toggle_show_raw,
"Raw Data"),
self.viewerControlWidget(),
layer))
del layer
return layers
def setupLayers( self, currentImageIndex ):
layers = []
def onButtonsEnabled(slot, roi):
currObj = self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].CurrentObjectName.value
hasSeg = self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].HasSegmentation.value
nzLB = self._carvingApplet.topLevelOperator.opLabeling.NonzeroLabelBlocks[currentImageIndex][:].wait()[0]
self.labelingDrawerUi.currentObjectLabel.setText("current object: %s" % currObj)
self.labelingDrawerUi.save.setEnabled(currObj != "" and hasSeg)
self.labelingDrawerUi.saveAs.setEnabled(currObj == "" and hasSeg)
#rethink this
#self.labelingDrawerUi.segment.setEnabled(len(nzLB) > 0)
#self.labelingDrawerUi.clear.setEnabled(len(nzLB) > 0)
self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].CurrentObjectName.notifyDirty(onButtonsEnabled)
self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].HasSegmentation.notifyDirty(onButtonsEnabled)
self._carvingApplet.topLevelOperator.opLabeling.NonzeroLabelBlocks[currentImageIndex].notifyDirty(onButtonsEnabled)
# Labels
labellayer, labelsrc = self.createLabelLayer(currentImageIndex, direct=True)
if labellayer is not None:
layers.append(labellayer)
# Tell the editor where to draw label data
self.editor.setLabelSink(labelsrc)
#segmentation
seg = self._carvingApplet.topLevelOperator.opCarving.Segmentation[currentImageIndex]
#seg = self._carvingApplet.topLevelOperator.opCarving[0]._mst.segmentation
#temp = self._done_lut[self._mst.regionVol[sl[1:4]]]
if seg.ready():
#source = RelabelingArraySource(seg)
#source.setRelabeling(numpy.arange(256, dtype=numpy.uint8))
colortable = [QColor(0,0,0,0).rgba(), QColor(0,0,0,0).rgba(), QColor(0,255,0).rgba()]
for i in range(256-len(colortable)):
r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255)
colortable.append(QColor(r,g,b).rgba())
#layer = DirectColorTableLayer(seg, colortable, lazyflow=True)
layer = ColortableLayer(LazyflowSource(seg), colortable, direct=True)
layer.name = "segmentation"
layer.visible = True
layer.opacity = 0.3
layers.append(layer)
#done
done = self._carvingApplet.topLevelOperator.opCarving.DoneObjects[currentImageIndex]
if done.ready():
colortable = [QColor(0,0,0,0).rgba(), QColor(0,0,255).rgba()]
for i in range(254-len(colortable)):
r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255)
colortable.append(QColor(r,g,b).rgba())
#have to use lazyflow because it provides dirty signals
#layer = DirectColorTableLayer(done, colortable, lazyflow=True)
layer = ColortableLayer(LazyflowSource(done), colortable, direct=True)
layer.name = "done"
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
doneSeg = self._carvingApplet.topLevelOperator.opCarving.DoneSegmentation[currentImageIndex]
if doneSeg.ready():
layer = ColortableLayer(LazyflowSource(doneSeg), self._doneSegmentationColortable, direct=True)
layer.name = "done seg"
layer.visible = False
layer.opacity = 0.5
self._doneSegmentationLayer = layer
layers.append(layer)
#supervoxel
sv = self._carvingApplet.topLevelOperator.opCarving.Supervoxels[currentImageIndex]
if sv.ready():
for i in range(256):
r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255)
colortable.append(QColor(r,g,b).rgba())
#layer = DirectColorTableLayer(sv, colortable, lazyflow=True)
layer = ColortableLayer(LazyflowSource(sv), colortable, direct=True)
layer.name = "supervoxels"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
#
# load additional layer: features / probability map
#
import h5py
f = h5py.File("pmap.h5")
pmap = f["data"].value
#
# here we load the actual raw data from an ArraySource rather than from a LazyflowSource for speed reasons
#
raw = self._carvingApplet.topLevelOperator.opCarving[0]._mst.raw
raw5D = numpy.zeros((1,)+raw.shape+(1,), dtype=raw.dtype)
raw5D[0,:,:,:,0] = raw[:,:,:]
#layer = DirectGrayscaleLayer(raw5D)
layer = GrayscaleLayer(ArraySource(raw5D), direct=True)
layer.name = "raw"
layer.visible = True
layer.opacity = 1.0
#layers.insert(1, layer)
layers.append(layer)
return layers
def setupLayers(self):
def findLayer(f, layerlist):
for l in layerlist:
if f(l):
return l
return None
layers = []
baseCarvingLayers = super(SplitBodyCarvingGui, self).setupLayers()
crosshairSlot = self.topLevelOperatorView.AnnotationCrosshairs
if crosshairSlot.ready():
# 0=Transparent, 1=pink
colortable = [
QColor(0, 0, 0, 0).rgba(),
QColor(236, 184, 201).rgba()
]
crosshairLayer = ColortableLayer(LazyflowSource(crosshairSlot),
colortable,
direct=True)
crosshairLayer.name = "Annotation Points"
crosshairLayer.visible = True
crosshairLayer.opacity = 1.0
layers.append(crosshairLayer)
highlightedObjectSlot = self.topLevelOperatorView.CurrentRavelerObject
if highlightedObjectSlot.ready():
# 0=Transparent, 1=blue
colortable = [QColor(0, 0, 0, 0).rgba(), QColor(0, 0, 255).rgba()]
highlightedObjectLayer = ColortableLayer(
LazyflowSource(highlightedObjectSlot), colortable, direct=True)
highlightedObjectLayer.name = "Current Raveler Object"
highlightedObjectLayer.visible = False
highlightedObjectLayer.opacity = 0.25
layers.append(highlightedObjectLayer)
remainingRavelerObjectSlot = self.topLevelOperatorView.CurrentRavelerObjectRemainder
if remainingRavelerObjectSlot.ready():
# 0=Transparent, 1=blue
colortable = [QColor(0, 0, 0, 0).rgba(), QColor(255, 0, 0).rgba()]
remainingObjectLayer = ColortableLayer(
LazyflowSource(remainingRavelerObjectSlot),
colortable,
direct=True)
remainingObjectLayer.name = "Remaining Raveler Object"
remainingObjectLayer.visible = True
remainingObjectLayer.opacity = 0.25
layers.append(remainingObjectLayer)
fragmentSegSlot = self.topLevelOperatorView.CurrentFragmentSegmentation
if fragmentSegSlot.ready():
colortable = map(QColor.rgba, self._fragmentColors)
fragSegLayer = ColortableLayer(LazyflowSource(fragmentSegSlot),
colortable,
direct=True)
fragSegLayer.name = "Saved Fragments"
fragSegLayer.visible = True
fragSegLayer.opacity = 0.25
layers.append(fragSegLayer)
ravelerLabelsSlot = self.topLevelOperatorView.RavelerLabels
if ravelerLabelsSlot.ready():
colortable = []
for i in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
ravelerLabelLayer = ColortableLayer(
LazyflowSource(ravelerLabelsSlot), colortable, direct=True)
ravelerLabelLayer.name = "Raveler Labels"
ravelerLabelLayer.visible = False
ravelerLabelLayer.opacity = 0.4
layers.append(ravelerLabelLayer)
maskedSegSlot = self.topLevelOperatorView.MaskedSegmentation
if maskedSegSlot.ready():
colortable = [
QColor(0, 0, 0, 0).rgba(),
QColor(0, 0, 0, 0).rgba(),
QColor(0, 255, 0).rgba()
]
maskedSegLayer = ColortableLayer(LazyflowSource(maskedSegSlot),
colortable,
direct=True)
maskedSegLayer.name = "Masked Segmentation"
maskedSegLayer.visible = True
maskedSegLayer.opacity = 0.3
layers.append(maskedSegLayer)
# Hide the original carving segmentation.
# TODO: Remove it from the list altogether?
carvingSeg = findLayer(lambda l: l.name == "segmentation",
baseCarvingLayers)
if carvingSeg is not None:
carvingSeg.visible = False
def removeBaseLayer(layerName):
layer = findLayer(lambda l: l.name == layerName, baseCarvingLayers)
if layer:
baseCarvingLayers.remove(layer)
# Don't show carving layers that aren't relevant to the split-body workflow
removeBaseLayer("Uncertainty")
removeBaseLayer("Segmentation")
removeBaseLayer("Completed segments (unicolor)")
#removeBaseLayer( "pmap" )
#removeBaseLayer( "hints" )
#removeBaseLayer( "done" )
#removeBaseLayer( "done" )
ActionInfo = ShortcutManager.ActionInfo
# Attach a shortcut to the raw data layer
if self.topLevelOperatorView.RawData.ready():
rawLayer = findLayer(lambda l: l.name == "Raw Data",
baseCarvingLayers)
assert rawLayer is not None, "Couldn't find the raw data layer. Did it's name change?"
rawLayer.shortcutRegistration = (
"f",
ActionInfo("Carving", "Raw Data to Top", "Raw Data to Top",
partial(self._toggleRawDataPosition, rawLayer),
self.viewerControlWidget(), rawLayer))
layers += baseCarvingLayers
return layers
def setupLayers(self):
layers = []
op = self.topLevelOperatorView
ravelerLabelsSlot = op.RavelerLabels
if ravelerLabelsSlot.ready():
colortable = []
for _ in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
ravelerLabelLayer = ColortableLayer(
LazyflowSource(ravelerLabelsSlot), colortable, direct=True)
ravelerLabelLayer.name = "Raveler Labels"
ravelerLabelLayer.visible = False
ravelerLabelLayer.opacity = 0.4
layers.append(ravelerLabelLayer)
supervoxelsSlot = op.Supervoxels
if supervoxelsSlot.ready():
colortable = []
for i in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
supervoxelsLayer = ColortableLayer(LazyflowSource(supervoxelsSlot),
colortable)
supervoxelsLayer.name = "Input Supervoxels"
supervoxelsLayer.visible = False
supervoxelsLayer.opacity = 1.0
layers.append(supervoxelsLayer)
def addFragmentSegmentationLayers(mslot, name):
if mslot.ready():
for index, slot in enumerate(mslot):
if slot.ready():
raveler_label = slot.meta.selected_label
colortable = []
for i in range(256):
r, g, b = numpy.random.randint(
0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
colortable[0] = QColor(0, 0, 0, 0).rgba()
fragSegLayer = ColortableLayer(LazyflowSource(slot),
colortable,
direct=True)
fragSegLayer.name = "{} #{} ({})".format(
name, index, raveler_label)
fragSegLayer.visible = False
fragSegLayer.opacity = 1.0
layers.append(fragSegLayer)
addFragmentSegmentationLayers(op.MaskedSupervoxels,
"Masked Supervoxels")
addFragmentSegmentationLayers(op.FilteredMaskedSupervoxels,
"Filtered Masked Supervoxels")
addFragmentSegmentationLayers(op.HoleFilledSupervoxels,
"Hole Filled Supervoxels")
addFragmentSegmentationLayers(op.RelabeledSupervoxels,
"Relabeled Supervoxels")
mslot = op.EditedRavelerBodies
for index, slot in enumerate(mslot):
if slot.ready():
raveler_label = slot.meta.selected_label
# 0=Black, 1=Transparent
colortable = [
QColor(0, 0, 0).rgba(),
QColor(0, 0, 0, 0).rgba()
]
bodyMaskLayer = ColortableLayer(LazyflowSource(slot),
colortable,
direct=True)
bodyMaskLayer.name = "Raveler Body Mask #{} ({})".format(
index, raveler_label)
bodyMaskLayer.visible = False
bodyMaskLayer.opacity = 1.0
layers.append(bodyMaskLayer)
finalSegSlot = op.FinalSupervoxels
if finalSegSlot.ready():
colortable = []
for _ in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
finalLayer = ColortableLayer(LazyflowSource(finalSegSlot),
colortable)
finalLayer.name = "Final Supervoxels"
finalLayer.visible = False
finalLayer.opacity = 0.4
layers.append(finalLayer)
inputSlot = op.InputData
if inputSlot.ready():
layer = GrayscaleLayer(LazyflowSource(inputSlot))
layer.name = "WS Input"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
#raw data
rawSlot = self.topLevelOperatorView.RawData
if rawSlot.ready():
raw5D = self.topLevelOperatorView.RawData.value
layer = GrayscaleLayer(ArraySource(raw5D), direct=True)
#layer = GrayscaleLayer( LazyflowSource(rawSlot) )
layer.name = "raw"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
return layers
def setupLayers(self):
print "setupLayers"
layers = []
def onButtonsEnabled(slot, roi):
currObj = self.topLevelOperatorView.CurrentObjectName.value
hasSeg = self.topLevelOperatorView.HasSegmentation.value
self.labelingDrawerUi.currentObjectLabel.setText(currObj)
self.labelingDrawerUi.save.setEnabled(hasSeg)
self.topLevelOperatorView.CurrentObjectName.notifyDirty(
onButtonsEnabled)
self.topLevelOperatorView.HasSegmentation.notifyDirty(onButtonsEnabled)
self.topLevelOperatorView.opLabelArray.NonzeroBlocks.notifyDirty(
onButtonsEnabled)
# Labels
labellayer, labelsrc = self.createLabelLayer(direct=True)
if labellayer is not None:
labellayer._allowToggleVisible = False
layers.append(labellayer)
# Tell the editor where to draw label data
self.editor.setLabelSink(labelsrc)
#uncertainty
if self._showUncertaintyLayer:
uncert = self.topLevelOperatorView.Uncertainty
if uncert.ready():
colortable = []
for i in range(256 - len(colortable)):
r, g, b, a = i, 0, 0, i
colortable.append(QColor(r, g, b, a).rgba())
layer = ColortableLayer(LazyflowSource(uncert),
colortable,
direct=True)
layer.name = "Uncertainty"
layer.visible = True
layer.opacity = 0.3
layers.append(layer)
#segmentation
seg = self.topLevelOperatorView.Segmentation
#seg = self.topLevelOperatorView.MST.value.segmentation
#temp = self._done_lut[self.MST.value.regionVol[sl[1:4]]]
if seg.ready():
#source = RelabelingArraySource(seg)
#source.setRelabeling(numpy.arange(256, dtype=numpy.uint8))
colortable = [
QColor(0, 0, 0, 0).rgba(),
QColor(0, 0, 0, 0).rgba(),
QColor(0, 255, 0).rgba()
]
for i in range(256 - len(colortable)):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
layer = ColortableLayer(LazyflowSource(seg),
colortable,
direct=True)
layer.name = "Segmentation"
layer.setToolTip("This layer displays the <i>current</i> segmentation. Simply add foreground and background " \
"labels, then press <i>Segment</i>.")
layer.visible = True
layer.opacity = 0.3
layers.append(layer)
#done
done = self.topLevelOperatorView.DoneObjects
if done.ready():
colortable = [QColor(0, 0, 0, 0).rgba(), QColor(0, 0, 255).rgba()]
for i in range(254 - len(colortable)):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
# ensure colors have sufficient distance to pure red and pure green
while (255 - r) + g + b < 128 or r + (255 - g) + b < 128:
r, g, b = numpy.random.randint(
0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
#have to use lazyflow because it provides dirty signals
layer = ColortableLayer(LazyflowSource(done),
colortable,
direct=True)
layer.name = "Completed segments (unicolor)"
layer.setToolTip("In order to keep track of which objects you have already completed, this layer " \
"shows <b>all completed object</b> in one color (<b>blue</b>). " \
"The reason for only one color is that for finding out which " \
"objects to label next, the identity of already completed objects is unimportant " \
"and destracting.")
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
#hints
'''
useLazyflow = True
ctable = [QColor(0,0,0,0).rgba(), QColor(255,0,0).rgba()]
ctable.extend( [QColor(255*random.random(), 255*random.random(), 255*random.random()) for x in range(254)] )
if useLazyflow:
hints = self.topLevelOperatorView.HintOverlay
layer = ColortableLayer(LazyflowSource(hints), ctable, direct=True)
else:
hints = self.topLevelOperatorView._hints
layer = ColortableLayer(ArraySource(hints), ctable, direct=True)
if not useLazyflow or hints.ready():
layer.name = "hints"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
'''
'''
#pmaps
useLazyflow = True
pmaps = self.topLevelOperatorView._pmap
if pmaps is not None:
layer = GrayscaleLayer(ArraySource(pmaps), direct=True)
layer.name = "pmap"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
'''
#done seg
doneSeg = self.topLevelOperatorView.DoneSegmentation
if doneSeg.ready():
if self._doneSegmentationLayer is None:
layer = ColortableLayer(LazyflowSource(doneSeg),
self._doneSegmentationColortable,
direct=True)
layer.name = "Completed segments (one color per object)"
layer.setToolTip("<html>In order to keep track of which objects you have already completed, this layer " \
"shows <b>all completed object</b>, each with a random color.</html>")
layer.visible = False
layer.opacity = 0.5
self._doneSegmentationLayer = layer
layers.append(layer)
else:
layers.append(self._doneSegmentationLayer)
#supervoxel
sv = self.topLevelOperatorView.Supervoxels
if sv.ready():
for i in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
layer = ColortableLayer(LazyflowSource(sv),
colortable,
direct=True)
layer.name = "Supervoxels"
layer.setToolTip("<html>This layer shows the partitioning of the input image into <b>supervoxels</b>. The carving " \
"algorithm uses these tiny puzzle-piceces to piece together the segmentation of an " \
"object. Sometimes, supervoxels are too large and straddle two distinct objects " \
"(undersegmentation). In this case, it will be impossible to achieve the desired " \
"segmentation. This layer helps you to understand these cases.</html>")
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
#raw data
'''
rawSlot = self.topLevelOperatorView.RawData
if rawSlot.ready():
raw5D = self.topLevelOperatorView.RawData.value
layer = GrayscaleLayer(ArraySource(raw5D), direct=True)
#layer = GrayscaleLayer( LazyflowSource(rawSlot) )
layer.visible = True
layer.name = 'raw'
layer.opacity = 1.0
layers.append(layer)
'''
inputSlot = self.topLevelOperatorView.InputData
if inputSlot.ready():
layer = GrayscaleLayer(LazyflowSource(inputSlot), direct=True)
layer.name = "Input Data"
layer.setToolTip(
"<html>The data originally loaded into ilastik (unprocessed).</html>"
)
#layer.visible = not rawSlot.ready()
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
filteredSlot = self.topLevelOperatorView.FilteredInputData
if filteredSlot.ready():
layer = GrayscaleLayer(LazyflowSource(filteredSlot))
layer.name = "Filtered Input"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
return layers
def setupLayers(self):
logger.debug("setupLayers")
layers = []
def onButtonsEnabled(slot, roi):
currObj = self.topLevelOperatorView.CurrentObjectName.value
hasSeg = self.topLevelOperatorView.HasSegmentation.value
self.labelingDrawerUi.currentObjectLabel.setText(currObj)
self.labelingDrawerUi.save.setEnabled(hasSeg)
self.topLevelOperatorView.CurrentObjectName.notifyDirty(
onButtonsEnabled)
self.topLevelOperatorView.HasSegmentation.notifyDirty(onButtonsEnabled)
self.topLevelOperatorView.opLabelArray.NonzeroBlocks.notifyDirty(
onButtonsEnabled)
# Labels
labellayer, labelsrc = self.createLabelLayer(direct=True)
if labellayer is not None:
labellayer._allowToggleVisible = False
layers.append(labellayer)
# Tell the editor where to draw label data
self.editor.setLabelSink(labelsrc)
#uncertainty
#if self._showUncertaintyLayer:
# uncert = self.topLevelOperatorView.Uncertainty
# if uncert.ready():
# colortable = []
# for i in range(256-len(colortable)):
# r,g,b,a = i,0,0,i
# colortable.append(QColor(r,g,b,a).rgba())
# layer = ColortableLayer(LazyflowSource(uncert), colortable, direct=True)
# layer.name = "Uncertainty"
# layer.visible = True
# layer.opacity = 0.3
# layers.append(layer)
#segmentation
seg = self.topLevelOperatorView.Segmentation
#seg = self.topLevelOperatorView.MST.value.segmentation
#temp = self._done_lut[self.MST.value.supervoxelUint32[sl[1:4]]]
if seg.ready():
#source = RelabelingArraySource(seg)
#source.setRelabeling(numpy.arange(256, dtype=numpy.uint8))
# assign to the object label color, 0 is transparent, 1 is background
colortable = [
QColor(0, 0, 0, 0).rgba(),
QColor(0, 0, 0, 0).rgba(), labellayer._colorTable[2]
]
for i in range(256 - len(colortable)):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
layer = ColortableLayer(LazyflowSource(seg),
colortable,
direct=True)
layer.name = "Segmentation"
layer.setToolTip("This layer displays the <i>current</i> segmentation. Simply add foreground and background " \
"labels, then press <i>Segment</i>.")
layer.visible = True
layer.opacity = 0.3
layers.append(layer)
#done
doneSeg = self.topLevelOperatorView.DoneSegmentation
if doneSeg.ready():
#FIXME: if the user segments more than 255 objects, those with indices that divide by 255 will be shown as transparent
#both here and in the _doneSegmentationColortable
colortable = 254 * [QColor(230, 25, 75).rgba()]
colortable.insert(0, QColor(0, 0, 0, 0).rgba())
#have to use lazyflow because it provides dirty signals
layer = ColortableLayer(LazyflowSource(doneSeg),
colortable,
direct=True)
layer.name = "Completed segments (unicolor)"
layer.setToolTip("In order to keep track of which objects you have already completed, this layer " \
"shows <b>all completed object</b> in one color (<b>blue</b>). " \
"The reason for only one color is that for finding out which " \
"objects to label next, the identity of already completed objects is unimportant " \
"and destracting.")
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
layer = ColortableLayer(LazyflowSource(doneSeg),
self._doneSegmentationColortable,
direct=True)
layer.name = "Completed segments (one color per object)"
layer.setToolTip("<html>In order to keep track of which objects you have already completed, this layer " \
"shows <b>all completed object</b>, each with a random color.</html>")
layer.visible = False
layer.opacity = 0.5
layer.colortableIsRandom = True
self._doneSegmentationLayer = layer
layers.append(layer)
#supervoxel
sv = self.topLevelOperatorView.Supervoxels
if sv.ready():
colortable = []
for i in range(256):
r, g, b = numpy.random.randint(0, 255), numpy.random.randint(
0, 255), numpy.random.randint(0, 255)
colortable.append(QColor(r, g, b).rgba())
layer = ColortableLayer(LazyflowSource(sv),
colortable,
direct=True)
layer.name = "Supervoxels"
layer.setToolTip("<html>This layer shows the partitioning of the input image into <b>supervoxels</b>. The carving " \
"algorithm uses these tiny puzzle-piceces to piece together the segmentation of an " \
"object. Sometimes, supervoxels are too large and straddle two distinct objects " \
"(undersegmentation). In this case, it will be impossible to achieve the desired " \
"segmentation. This layer helps you to understand these cases.</html>")
layer.visible = False
layer.colortableIsRandom = True
layer.opacity = 0.5
layers.append(layer)
# Visual overlay (just for easier labeling)
overlaySlot = self.topLevelOperatorView.OverlayData
if overlaySlot.ready():
overlay5D = self.topLevelOperatorView.OverlayData.value
layer = GrayscaleLayer(ArraySource(overlay5D), direct=True)
layer.visible = True
layer.name = 'Overlay'
layer.opacity = 1.0
# if the flag window_leveling is set the contrast
# of the layer is adjustable
layer.window_leveling = True
self.labelingDrawerUi.thresToolButton.show()
layers.append(layer)
del layer
inputSlot = self.topLevelOperatorView.InputData
if inputSlot.ready():
layer = GrayscaleLayer(LazyflowSource(inputSlot), direct=True)
layer.name = "Input Data"
layer.setToolTip(
"<html>The data originally loaded into ilastik (unprocessed).</html>"
)
#layer.visible = not rawSlot.ready()
layer.visible = True
layer.opacity = 1.0
# Window leveling is already active on the Overlay,
# but if no overlay was provided, then activate window_leveling on the raw data instead.
if not overlaySlot.ready():
# if the flag window_leveling is set the contrast
# of the layer is adjustable
layer.window_leveling = True
self.labelingDrawerUi.thresToolButton.show()
layers.append(layer)
del layer
filteredSlot = self.topLevelOperatorView.FilteredInputData
if filteredSlot.ready():
layer = GrayscaleLayer(LazyflowSource(filteredSlot))
layer.name = "Filtered Input"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
return layers
def setupLayers(self):
layers = []
op = self.topLevelOperatorView
ActionInfo = ShortcutManager.ActionInfo
# Superpixels -- Edge Labels
if op.Superpixels.ready() and op.EdgeLabelsDict.ready():
edge_labels = op.EdgeLabelsDict.value
layer = LabelableSegmentationEdgesLayer(
LazyflowSource(op.Superpixels), self.edge_label_pen_table,
edge_labels)
layer.name = "Edge Labels"
layer.visible = True
layer.opacity = 1.0
self.update_labeled_edges() # Initialize
layer.labelsChanged.connect(self._handle_edge_label_clicked)
layer.contexts.append(self.create_prefetch_menu("Edge Labels"))
layer.shortcutRegistration = ("0",
ActionInfo(
"Edge Training Layers",
"LabelVisibility",
"Show/Hide Edge Labels",
layer.toggleVisible,
self.viewerControlWidget(),
layer))
layers.append(layer)
del layer
# Superpixels -- Edge Probabilities
if op.Superpixels.ready() and op.EdgeProbabilitiesDict.ready():
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels))
layer.name = "Edge Probabilities" # Name is hard-coded in multiple places: grep before changing.
layer.visible = False
layer.opacity = 1.0
self.update_probability_edges() # Initialize
layer.contexts.append(
self.create_prefetch_menu("Edge Probabilities"))
layer.shortcutRegistration = ("p",
ActionInfo(
"Edge Training Layers",
"EdgePredictionsVisibility",
"Show/Hide Edge Predictions",
layer.toggleVisible,
self.viewerControlWidget(),
layer))
layers.append(layer)
del layer
# Superpixels -- Edges
if op.Superpixels.ready():
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.yellow)
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels),
default_pen)
layer.name = "Superpixel Edges"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
del layer
# Naive Segmentation
if op.NaiveSegmentation.ready():
layer = self.createStandardLayerFromSlot(op.NaiveSegmentation)
layer.name = "Naive Segmentation"
layer.visible = False
layer.opacity = 0.5
layer.shortcutRegistration = (
"n",
ActionInfo(
"Edge Training Layers", "NaiveSegmentationVisibility",
"Show/Hide Naive Segmentation (shows output if classifier output is respected verbatim)",
layer.toggleVisible, self.viewerControlWidget(), layer))
layers.append(layer)
del layer
# Groundtruth
if op.GroundtruthSegmentation.ready():
layer = self.createStandardLayerFromSlot(
op.GroundtruthSegmentation)
layer.name = "Groundtruth"
layer.visible = False
layer.opacity = 0.5
layer.shortcutRegistration = ("g",
ActionInfo(
"Edge Training Layers",
"GroundtruthVisibility",
"Show/Hide Groundtruth",
layer.toggleVisible,
self.viewerControlWidget(),
layer))
layers.append(layer)
del layer
# Voxel data
if op.VoxelData.ready():
layer = self._create_grayscale_layer_from_slot(
op.VoxelData,
op.VoxelData.meta.getTaggedShape()['c'])
layer.name = "Voxel Data"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.RawData.ready():
layer = self.createStandardLayerFromSlot(op.RawData)
layer.name = "Raw Data"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
layer.shortcutRegistration = ("i",
ActionInfo(
"Edge Training Layers",
"Hide all but Raw",
"Hide all but Raw",
partial(self.toggle_show_raw,
"Raw Data"),
self.viewerControlWidget(),
layer))
del layer
return layers
def setupLayers(self):
layers = []
op = self.topLevelOperatorView
ravelerLabelsSlot = op.RavelerLabels
if ravelerLabelsSlot.ready():
colortable = []
for _ in range(256):
r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255)
colortable.append(QColor(r,g,b).rgba())
ravelerLabelLayer = ColortableLayer(LazyflowSource(ravelerLabelsSlot), colortable, direct=True)
ravelerLabelLayer.name = "Raveler Labels"
ravelerLabelLayer.visible = False
ravelerLabelLayer.opacity = 0.4
layers.append(ravelerLabelLayer)
def addFragmentSegmentationLayers(mslot, name):
if mslot.ready():
for index, slot in enumerate(mslot):
if slot.ready():
raveler_label = slot.meta.selected_label
colortable = map(QColor.rgba, self._fragmentColors)
fragSegLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True)
fragSegLayer.name = "{} #{} ({})".format( name, index, raveler_label )
fragSegLayer.visible = False
fragSegLayer.opacity = 1.0
layers.append(fragSegLayer)
addFragmentSegmentationLayers( op.FragmentedBodies, "Saved Fragments" )
addFragmentSegmentationLayers( op.RelabeledFragments, "Relabeled Fragments" )
addFragmentSegmentationLayers( op.FilteredFragmentedBodies, "CC-Filtered Fragments" )
addFragmentSegmentationLayers( op.WatershedFilledBodies, "Watershed-filled Fragments" )
mslot = op.EditedRavelerBodies
for index, slot in enumerate(mslot):
if slot.ready():
raveler_label = slot.meta.selected_label
# 0=Black, 1=Transparent
colortable = [QColor(0, 0, 0).rgba(), QColor(0, 0, 0, 0).rgba()]
bodyMaskLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True)
bodyMaskLayer.name = "Raveler Body Mask #{} ({})".format( index, raveler_label )
bodyMaskLayer.visible = False
bodyMaskLayer.opacity = 1.0
layers.append(bodyMaskLayer)
finalSegSlot = op.FinalSegmentation
if finalSegSlot.ready():
colortable = []
for _ in range(256):
r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255)
colortable.append(QColor(r,g,b).rgba())
finalLayer = ColortableLayer(LazyflowSource(finalSegSlot), colortable, direct=True)
finalLayer.name = "Final Segmentation"
finalLayer.visible = False
finalLayer.opacity = 0.4
layers.append(finalLayer)
inputSlot = op.InputData
if inputSlot.ready():
layer = GrayscaleLayer( LazyflowSource(inputSlot) )
layer.name = "WS Input"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
#raw data
rawSlot = self.topLevelOperatorView.RawData
rawLayer = None
if rawSlot.ready():
raw5D = self.topLevelOperatorView.RawData.value
rawLayer = GrayscaleLayer(ArraySource(raw5D), direct=True)
#rawLayer = GrayscaleLayer( LazyflowSource(rawSlot) )
rawLayer.name = "raw"
rawLayer.visible = True
rawLayer.opacity = 1.0
rawLayer.shortcutRegistration = ( "g", ShortcutManager.ActionInfo(
"Postprocessing",
"Raw Data to Top",
"Raw Data to Top",
partial(self._toggleRawDataPosition, rawLayer),
self.viewerControlWidget(),
rawLayer ) )
layers.append(rawLayer)
return layers
