def _onReady(self, slot):
if slot is self.mainOperator.RawImage:
if slot.meta.shape and not self.rawsrc:
self.rawsrc = LazyflowSource(self.mainOperator.RawImage)
layerraw = GrayscaleLayer(self.rawsrc)
layerraw.name = "Raw"
self.layerstack.append(layerraw)
def _onReady( self, slot ):
if slot is self.mainOperator.RawImage:
if slot.meta.shape and not self.rawsrc:
self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
layerraw = GrayscaleLayer( self.rawsrc )
layerraw.name = "Raw"
self.layerstack.append( layerraw )
def _onMetaChanged( self, slot ):
if slot is self.mainOperator.BinaryImage:
if slot.meta.shape:
self.editor.dataShape = slot.meta.shape
if slot is self.mainOperator.RawImage:
if slot.meta.shape and not self.rawsrc:
self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
layerraw = GrayscaleLayer( self.rawsrc )
layerraw.name = "Raw Image"
self.layerstack.append( layerraw )
def setupLayers( self ):
layers = []
self.translationsrc = self.mainOperator.TranslationVectorsDisplay
translationLayer = self.createStandardLayerFromSlot( self.translationsrc )
translationLayer.name = "Translation Vector"
translationLayer.opacity = 0.8
translationLayer.visible = False
layers.append(translationLayer)
ct = colortables.create_default_8bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
ct[1] = QColor(0,255,0,255).rgba() # foreground is green
self.warpedSrc = LazyflowSource( self.mainOperator.WarpedImage )
warpedLayer = ColortableLayer( self.warpedSrc, ct )
warpedLayer.name = "Translation Corrected Binary Image"
warpedLayer.visible = False
warpedLayer.opacity = 0.4
layers.append(warpedLayer)
ct = colortables.create_default_8bit()
ct[0] = QColor(0,0,0,0).rgba() # make 0 transparent
ct[1] = QColor(255,0,0,255).rgba() # foreground is read
self.binarySrc = LazyflowSource( self.mainOperator.BinaryImage )
binaryLayer = ColortableLayer( self.binarySrc, ct )
binaryLayer.name = "Binary Image"
binaryLayer.visible = True
binaryLayer.opacity = 0.8
layers.append(binaryLayer)
## raw data layer
self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
rawLayer = GrayscaleLayer( self.rawsrc )
rawLayer.name = "Raw Image"
layers.insert( len(layers), rawLayer )
if self.topLevelOperatorView.TranslationVectors.meta.shape:
self.editor.dataShape = self.topLevelOperatorView.TranslationVectors.meta.shape
self.topLevelOperatorView.RawImage.notifyReady( self._onReady )
self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged )
self._onParametersChanged()
self._drawer.methodBox.currentIndexChanged.connect(self._onMethodChanged)
self._drawer.templateSizeBox.valueChanged.connect(self._onMethodChanged)
self._drawer.maxTranslationBox.valueChanged.connect(self._onMethodChanged)
self._drawer.maxDiffValsBox.valueChanged.connect(self._onMethodChanged)
return layers
def _onMetaChanged(self, slot):
if slot is self.mainOperator.LabelImage:
if slot.meta.shape:
self.editor.dataShape = slot.meta.shape
maxt = slot.meta.shape[0] - 1
self._setRanges()
self._drawer.from_time.setValue(0)
self._drawer.to_time.setValue(maxt)
if slot is self.mainOperator.RawImage:
if slot.meta.shape and not self.rawsrc:
self.rawsrc = LazyflowSource(self.mainOperator.RawImage)
layerraw = GrayscaleLayer(self.rawsrc)
layerraw.name = "Raw"
self.layerstack.append(layerraw)
def _onMetaChanged( self, slot ):
if slot is self.mainOperator.LabelImage:
if slot.meta.shape:
self.editor.dataShape = slot.meta.shape
maxt = slot.meta.shape[0] - 1
self._setRanges()
self._drawer.from_time.setValue(0)
self._drawer.to_time.setValue(maxt)
if slot is self.mainOperator.RawImage:
if slot.meta.shape and not self.rawsrc:
self.rawsrc = LazyflowSource( self.mainOperator.RawImage )
layerraw = GrayscaleLayer( self.rawsrc )
layerraw.name = "Raw"
self.layerstack.append( layerraw )
def _add_grayscale_layer(self, data, name=None, visible=False):
'''
adds a grayscale layer to the layerstack
:param data: numpy array (2D) containing the data
:param name: name of layer
:param visible: bool determining whether this layer should be set to visible
:return:
'''
#assert len(data.shape) == 2
a, data_shape = createDataSource(data, True)
self.editor.dataShape = list(data_shape)
new_layer = GrayscaleLayer(a)
new_layer.visible = visible
if name is not None:
new_layer.name = name
self.layerstack.append(new_layer)
def _add_grayscale_layer(self, data, name=None, visible=False):
'''
adds a grayscale layer to the layerstack
:param data: numpy array (2D) containing the data
:param name: name of layer
:param visible: bool determining whether this layer should be set to visible
:return:
'''
#assert len(data.shape) == 2
a, data_shape = createDataSource(data, True)
self.editor.dataShape = list(data_shape)
new_layer = GrayscaleLayer(a)
new_layer.visible = visible
if name is not None:
new_layer.name = name
self.layerstack.append(new_layer)
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 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 showStuff(raw_name,
pred_viewer1,
pred_viewer2,
cutout_name,
one_extra=None):
# display the raw and annotations for cremi challenge data
raw = vigra.impex.readHDF5(indir + datasets[raw_name], "data", order='C')
# raw_old = vigra.readHDF5(indir+datasets["raw_bad"], "data", order = 'C')
defect_prediction_128 = vigra.impex.readHDF5(indir +
datasets[pred_viewer2],
"data",
order='C')
defect_prediction_150 = vigra.impex.readHDF5(indir +
datasets[pred_viewer1],
"data",
order='C')
cutout_from_150_pred = vigra.impex.readHDF5(indir + datasets[cutout_name],
"data",
order='C')
####################################################################################################################
# only used for fast testing stuff
#change_one = vigra.readHDF5(indir+datasets["segmentation_on_equalized_image"], "data", order = 'C')
#pdb.set_trace()
#defect_prediction_150[1,:,:] = change_one[0,:,:,0]
####################################################################################################################
# defect_prediction_150 = gt[..., 0]
cutout = numpy.asarray(cutout_from_150_pred)
rawdata = numpy.asarray(raw)
# rawdata_old = numpy.asarray(raw_old)
# op5ify
# shape5d = rawdata.shape
shape5d = (1, ) + rawdata.shape + (1, )
print shape5d, rawdata.shape, rawdata.dtype
app = QApplication([])
v = Viewer()
direct = False
# layer for raw data
rawdata = numpy.reshape(rawdata, shape5d)
rawsource = ArraySource(rawdata)
v.dataShape = shape5d
lraw = GrayscaleLayer(rawsource, direct=direct)
lraw.visible = True
lraw.name = "raw"
v.layerstack.append(lraw)
# layer for cutout regions from raw data
cutout = numpy.reshape(cutout, shape5d)
cutoutsource = ArraySource(cutout)
lcutout = GrayscaleLayer(cutoutsource, direct=direct)
lcutout.visible = False
lcutout.name = "cut_out"
v.layerstack.append(lcutout)
# layer for first prediction result
defect_prediction_128 = numpy.reshape(defect_prediction_128, shape5d)
synsource = ArraySource(defect_prediction_128)
ct = create_random_16bit()
ct[0] = 0
lsyn = ColortableLayer(synsource, ct)
lsyn.name = pred_viewer2
lsyn.visible = False
v.layerstack.append(lsyn)
# layer for second prediction result
segm = numpy.reshape(defect_prediction_150, shape5d)
segsource = ArraySource(segm)
ct = create_random_16bit()
ct[0] = 0
lseg = ColortableLayer(segsource, ct)
lseg.name = pred_viewer1
lseg.visible = False
v.layerstack.append(lseg)
if one_extra is None:
v.showMaximized()
app.exec_()
if one_extra is not None:
# layer for third prediction result
extra_prediction = vigra.readHDF5(indir + datasets[one_extra],
"data",
order='C')
extra_pred_reshaped = numpy.reshape(extra_prediction, shape5d)
segsource = ArraySource(extra_pred_reshaped)
ct = create_random_16bit()
ct[0] = 0
# ct = create_default_16bit()
lseg = ColortableLayer(segsource, ct)
lseg.name = one_extra
lseg.visible = False
v.layerstack.append(lseg)
v.showMaximized()
app.exec_()
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 showStuff(raw_name, pred_viewer1, pred_viewer2, cutout_name, one_extra = None):
# display the raw and annotations for cremi challenge data
raw = vigra.impex.readHDF5(indir+datasets[raw_name], "data", order = 'C')
# raw_old = vigra.readHDF5(indir+datasets["raw_bad"], "data", order = 'C')
defect_prediction_128 = vigra.impex.readHDF5(indir+datasets[pred_viewer2], "data", order = 'C')
defect_prediction_150 = vigra.impex.readHDF5(indir+datasets[pred_viewer1], "data", order = 'C')
cutout_from_150_pred = vigra.impex.readHDF5(indir+datasets[cutout_name], "data", order = 'C')
####################################################################################################################
# only used for fast testing stuff
#change_one = vigra.readHDF5(indir+datasets["segmentation_on_equalized_image"], "data", order = 'C')
#pdb.set_trace()
#defect_prediction_150[1,:,:] = change_one[0,:,:,0]
####################################################################################################################
# defect_prediction_150 = gt[..., 0]
cutout = numpy.asarray(cutout_from_150_pred)
rawdata = numpy.asarray(raw)
# rawdata_old = numpy.asarray(raw_old)
# op5ify
# shape5d = rawdata.shape
shape5d = (1,)+rawdata.shape+(1,)
print shape5d, rawdata.shape, rawdata.dtype
app = QApplication([])
v = Viewer()
direct = False
# layer for raw data
rawdata = numpy.reshape(rawdata, shape5d)
rawsource = ArraySource(rawdata)
v.dataShape = shape5d
lraw = GrayscaleLayer(rawsource, direct=direct)
lraw.visible = True
lraw.name = "raw"
v.layerstack.append(lraw)
# layer for cutout regions from raw data
cutout = numpy.reshape(cutout, shape5d)
cutoutsource = ArraySource(cutout)
lcutout = GrayscaleLayer(cutoutsource, direct = direct)
lcutout.visible = False
lcutout.name = "cut_out"
v.layerstack.append(lcutout)
# layer for first prediction result
defect_prediction_128 = numpy.reshape(defect_prediction_128, shape5d)
synsource = ArraySource(defect_prediction_128)
ct = create_random_16bit()
ct[0] = 0
lsyn = ColortableLayer(synsource, ct)
lsyn.name = pred_viewer2
lsyn.visible = False
v.layerstack.append(lsyn)
# layer for second prediction result
segm = numpy.reshape(defect_prediction_150, shape5d)
segsource = ArraySource(segm)
ct = create_random_16bit()
ct[0] = 0
lseg = ColortableLayer(segsource, ct)
lseg.name = pred_viewer1
lseg.visible = False
v.layerstack.append(lseg)
if one_extra is None:
v.showMaximized()
app.exec_()
if one_extra is not None:
# layer for third prediction result
extra_prediction = vigra.readHDF5(indir+datasets[one_extra], "data", order = 'C')
extra_pred_reshaped = numpy.reshape(extra_prediction, shape5d)
segsource = ArraySource(extra_pred_reshaped)
ct = create_random_16bit()
ct[0] = 0
# ct = create_default_16bit()
lseg = ColortableLayer(segsource, ct)
lseg.name = one_extra
lseg.visible = False
v.layerstack.append(lseg)
v.showMaximized()
app.exec_()
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
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 ):
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
from volumina.layer import ColortableLayer, GrayscaleLayer
from PyQt5.QtWidgets import QApplication
SHAPE = (1, 600, 800, 1, 1) # volumina expects 5d txyzc
data_arr = (255 * numpy.random.random(SHAPE)).astype(numpy.uint8)
label_arr = numpy.zeros(SHAPE, dtype=numpy.uint8)
##-----
app = QApplication(sys.argv)
v = Viewer()
data_src = ArraySource(data_arr)
data_layer = GrayscaleLayer(data_src)
data_layer.name = "Raw"
data_layer.numberOfChannels = 1
label_src = ArraySinkSource(label_arr)
label_layer = ColortableLayer(label_src,
colorTable=default16_new,
direct=False)
label_layer.name = "Labels"
label_layer.ref_object = None
assert SHAPE == label_arr.shape == data_arr.shape
v.dataShape = SHAPE
v.layerstack.append(data_layer)
v.layerstack.append(label_layer)
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
