def connectLane(self, laneIndex):
"""
Override from base class.
"""
opDataSelection = self.dataSelectionApplet.topLevelOperator.getLane(laneIndex)
opWsdt = self.wsdtApplet.topLevelOperator.getLane(laneIndex)
opEdgeTraining = self.edgeTrainingApplet.topLevelOperator.getLane(laneIndex)
opMulticut = self.multicutApplet.topLevelOperator.getLane(laneIndex)
opDataExport = self.dataExportApplet.topLevelOperator.getLane(laneIndex)
opConvertRaw = OpConvertDtype( parent=self )
opConvertRaw.ConversionDtype.setValue( np.float32 )
opConvertRaw.Input.connect( opDataSelection.ImageGroup[self.DATA_ROLE_RAW] )
opConvertProbabilities = OpConvertDtype( parent=self )
opConvertProbabilities.ConversionDtype.setValue( np.float32 )
opConvertProbabilities.Input.connect( opDataSelection.ImageGroup[self.DATA_ROLE_PROBABILITIES] )
# watershed inputs
opWsdt.RawData.connect( opDataSelection.ImageGroup[self.DATA_ROLE_RAW] )
opWsdt.Input.connect( opDataSelection.ImageGroup[self.DATA_ROLE_PROBABILITIES] )
# Actual computation is done with both RawData and Probabilities
opStackRawAndVoxels = OpSimpleStacker( parent=self )
opStackRawAndVoxels.Images.resize(2)
opStackRawAndVoxels.Images[0].connect( opConvertRaw.Output )
opStackRawAndVoxels.Images[1].connect( opConvertProbabilities.Output )
opStackRawAndVoxels.AxisFlag.setValue('c')
# If superpixels are available from a file, use it.
opSuperpixelsSelect = OpPrecomputedInput( ignore_dirty_input=True, parent=self )
opSuperpixelsSelect.PrecomputedInput.connect( opDataSelection.ImageGroup[self.DATA_ROLE_SUPERPIXELS] )
opSuperpixelsSelect.SlowInput.connect( opWsdt.Superpixels )
# If the superpixel file changes, then we have to remove the training labels from the image
def handle_new_superpixels( *args ):
opEdgeTraining.handle_dirty_superpixels( opEdgeTraining.Superpixels )
opDataSelection.ImageGroup[self.DATA_ROLE_SUPERPIXELS].notifyReady( handle_new_superpixels )
opDataSelection.ImageGroup[self.DATA_ROLE_SUPERPIXELS].notifyUnready( handle_new_superpixels )
# edge training inputs
opEdgeTraining.RawData.connect( opDataSelection.ImageGroup[self.DATA_ROLE_RAW] ) # Used for visualization only
opEdgeTraining.VoxelData.connect( opStackRawAndVoxels.Output )
opEdgeTraining.Superpixels.connect( opSuperpixelsSelect.Output )
opEdgeTraining.GroundtruthSegmentation.connect( opDataSelection.ImageGroup[self.DATA_ROLE_GROUNDTRUTH] )
# multicut inputs
opMulticut.Superpixels.connect( opEdgeTraining.Superpixels )
opMulticut.Rag.connect( opEdgeTraining.Rag )
opMulticut.EdgeProbabilities.connect( opEdgeTraining.EdgeProbabilities )
opMulticut.EdgeProbabilitiesDict.connect( opEdgeTraining.EdgeProbabilitiesDict )
opMulticut.RawData.connect( opDataSelection.ImageGroup[self.DATA_ROLE_RAW] )
# DataExport inputs
opDataExport.RawData.connect( opDataSelection.ImageGroup[self.DATA_ROLE_RAW] )
opDataExport.RawDatasetInfo.connect( opDataSelection.DatasetGroup[self.DATA_ROLE_RAW] )
opDataExport.Inputs.resize( len(self.EXPORT_NAMES) )
opDataExport.Inputs[0].connect( opMulticut.Output )
for slot in opDataExport.Inputs:
assert slot.partner is not None
def testBasic(self):
inputA = vigra.taggedView(1 * np.ones((100, 100, 5), dtype=np.uint32),
"yxc")
inputB = vigra.taggedView(2 * np.ones((100, 100, 10), dtype=np.uint32),
"yxc")
inputC = vigra.taggedView(3 * np.ones((100, 100, 20), dtype=np.uint32),
"yxc")
op = OpSimpleStacker(graph=Graph())
op.Images.resize(3)
op.Images[0].setValue(inputA)
op.Images[1].setValue(inputB)
op.Images[2].setValue(inputC)
op.AxisFlag.setValue("c")
assert op.Output.ready()
assert op.Output.meta.shape == (100, 100, 35)
assert op.Output.meta.dtype == np.uint32
def connectLane(self, laneIndex):
"""
Override from base class.
"""
opDataSelection = self.dataSelectionApplet.topLevelOperator.getLane(
laneIndex)
opWsdt = self.wsdtApplet.topLevelOperator.getLane(laneIndex)
opEdgeTrainingWithMulticut = self.edgeTrainingWithMulticutApplet.topLevelOperator.getLane(
laneIndex)
opDataExport = self.dataExportApplet.topLevelOperator.getLane(
laneIndex)
# RAW DATA: Convert to float32
opConvertRaw = OpConvertDtype(parent=self)
opConvertRaw.ConversionDtype.setValue(np.float32)
opConvertRaw.Input.connect(
opDataSelection.ImageGroup[self.DATA_ROLE_RAW])
# PROBABILITIES: Convert to float32
opConvertProbabilities = OpConvertDtype(parent=self)
opConvertProbabilities.ConversionDtype.setValue(np.float32)
opConvertProbabilities.Input.connect(
opDataSelection.ImageGroup[self.DATA_ROLE_PROBABILITIES])
# PROBABILITIES: Normalize drange to [0.0, 1.0]
opNormalizeProbabilities = OpPixelOperator(parent=self)
def normalize_inplace(a):
drange = opNormalizeProbabilities.Input.meta.drange
if drange is None or (drange[0] == 0.0 and drange[1] == 1.0):
return a
a[:] -= drange[0]
a[:] /= (drange[1] - drange[0])
return a
opNormalizeProbabilities.Input.connect(opConvertProbabilities.Output)
opNormalizeProbabilities.Function.setValue(normalize_inplace)
# GROUNDTRUTH: Convert to uint32, relabel, and cache
opConvertGroundtruth = OpConvertDtype(parent=self)
opConvertGroundtruth.ConversionDtype.setValue(np.uint32)
opConvertGroundtruth.Input.connect(
opDataSelection.ImageGroup[self.DATA_ROLE_GROUNDTRUTH])
opRelabelGroundtruth = OpRelabelConsecutive(parent=self)
opRelabelGroundtruth.Input.connect(opConvertGroundtruth.Output)
opGroundtruthCache = OpBlockedArrayCache(parent=self)
opGroundtruthCache.CompressionEnabled.setValue(True)
opGroundtruthCache.Input.connect(opRelabelGroundtruth.Output)
# watershed inputs
opWsdt.RawData.connect(opDataSelection.ImageGroup[self.DATA_ROLE_RAW])
opWsdt.Input.connect(opNormalizeProbabilities.Output)
# Actual computation is done with both RawData and Probabilities
opStackRawAndVoxels = OpSimpleStacker(parent=self)
opStackRawAndVoxels.Images.resize(2)
opStackRawAndVoxels.Images[0].connect(opConvertRaw.Output)
opStackRawAndVoxels.Images[1].connect(opNormalizeProbabilities.Output)
opStackRawAndVoxels.AxisFlag.setValue('c')
# If superpixels are available from a file, use it.
opSuperpixelsSelect = OpPrecomputedInput(ignore_dirty_input=True,
parent=self)
opSuperpixelsSelect.PrecomputedInput.connect(
opDataSelection.ImageGroup[self.DATA_ROLE_SUPERPIXELS])
opSuperpixelsSelect.SlowInput.connect(opWsdt.Superpixels)
# If the superpixel file changes, then we have to remove the training labels from the image
opEdgeTraining = opEdgeTrainingWithMulticut.opEdgeTraining
def handle_new_superpixels(*args):
opEdgeTraining.handle_dirty_superpixels(opEdgeTraining.Superpixels)
opDataSelection.ImageGroup[self.DATA_ROLE_SUPERPIXELS].notifyReady(
handle_new_superpixels)
opDataSelection.ImageGroup[self.DATA_ROLE_SUPERPIXELS].notifyUnready(
handle_new_superpixels)
# edge training inputs
opEdgeTrainingWithMulticut.RawData.connect(opDataSelection.ImageGroup[
self.DATA_ROLE_RAW]) # Used for visualization only
opEdgeTrainingWithMulticut.VoxelData.connect(
opStackRawAndVoxels.Output)
opEdgeTrainingWithMulticut.Superpixels.connect(
opSuperpixelsSelect.Output)
opEdgeTrainingWithMulticut.GroundtruthSegmentation.connect(
opGroundtruthCache.Output)
# DataExport inputs
opDataExport.RawData.connect(
opDataSelection.ImageGroup[self.DATA_ROLE_RAW])
opDataExport.RawDatasetInfo.connect(
opDataSelection.DatasetGroup[self.DATA_ROLE_RAW])
opDataExport.Inputs.resize(len(self.EXPORT_NAMES))
opDataExport.Inputs[0].connect(opEdgeTrainingWithMulticut.Output)
for slot in opDataExport.Inputs:
assert slot.partner is not None