def __init__(self, *args, **kwargs):
super(OpCachedWsdt, self).__init__(*args, **kwargs)
my_slot_names = set(
map(lambda slot: slot.name, self.inputSlots + self.outputSlots))
wsdt_slot_names = set(
map(lambda slot: slot.name,
OpWsdt.inputSlots + OpWsdt.outputSlots))
assert wsdt_slot_names.issubset(my_slot_names), \
"OpCachedWsdt should have all of the slots that OpWsdt has (and maybe more). "\
"Did you add a slot to OpWsdt and forget to add it to OpCachedWsdt?"
self._opWsdt = OpWsdt(parent=self)
self._opWsdt.Input.connect(self.Input)
self._opWsdt.ChannelSelection.connect(self.ChannelSelection)
self._opWsdt.Pmin.connect(self.Pmin)
self._opWsdt.MinMembraneSize.connect(self.MinMembraneSize)
self._opWsdt.MinSegmentSize.connect(self.MinSegmentSize)
self._opWsdt.SigmaMinima.connect(self.SigmaMinima)
self._opWsdt.SigmaWeights.connect(self.SigmaWeights)
self._opWsdt.GroupSeeds.connect(self.GroupSeeds)
self._opWsdt.EnableDebugOutputs.connect(self.EnableDebugOutputs)
self._opCache = OpBlockedArrayCache(parent=self)
self._opCache.fixAtCurrent.connect(self.FreezeCache)
self._opCache.Input.connect(self._opWsdt.Superpixels)
self.Superpixels.connect(self._opCache.Output)
self.CleanBlocks.connect(self._opCache.CleanBlocks)
self._opSelectedInput = OpSingleChannelSelector(parent=self)
self._opSelectedInput.Index.connect(self.ChannelSelection)
self._opSelectedInput.Input.connect(self.Input)
self._opThreshold = OpPixelOperator(parent=self)
self._opThreshold.Input.connect(self._opSelectedInput.Output)
self.ThresholdedInput.connect(self._opThreshold.Output)
def __init__(self, *args, **kwargs):
super(OpCachedWsdt, self).__init__(*args, **kwargs)
my_slot_names = set(
[slot.name for slot in self.inputSlots + self.outputSlots])
wsdt_slot_names = set(
[slot.name for slot in OpWsdt.inputSlots + OpWsdt.outputSlots])
assert wsdt_slot_names.issubset(my_slot_names), (
"OpCachedWsdt should have all of the slots that OpWsdt has (and maybe more)."
"Did you add a slot to OpWsdt and forget to add it to OpCachedWsdt?"
)
self._opWsdt = OpWsdt(parent=self)
self._opWsdt.Input.connect(self.Input)
self._opWsdt.ChannelSelections.connect(self.ChannelSelections)
self._opWsdt.Threshold.connect(self.Threshold)
self._opWsdt.MinSize.connect(self.MinSize)
self._opWsdt.Sigma.connect(self.Sigma)
self._opWsdt.Alpha.connect(self.Alpha)
self._opWsdt.PixelPitch.connect(self.PixelPitch)
self._opWsdt.ApplyNonmaxSuppression.connect(
self.ApplyNonmaxSuppression)
self._opWsdt.InvertPixelProbabilities.connect(
self.InvertPixelProbabilities)
self._opWsdt.EnableDebugOutputs.connect(self.EnableDebugOutputs)
self._opCache = OpBlockedArrayCache(parent=self)
self._opCache.fixAtCurrent.connect(self.FreezeCache)
self._opCache.Input.connect(self._opWsdt.Superpixels)
self.Superpixels.connect(self._opCache.Output)
self.CleanBlocks.connect(self._opCache.CleanBlocks)
self._opSelectedInput = OpSumChannels(parent=self)
self._opSelectedInput.ChannelSelections.connect(self.ChannelSelections)
self._opSelectedInput.Input.connect(self.Input)
self._opSelectedInput.InvertPixelProbabilities.connect(
self.InvertPixelProbabilities)
self.SelectedInput.connect(self._opSelectedInput.Output)
self._opThreshold = OpPixelOperator(parent=self)
self._opThreshold.Input.connect(self._opSelectedInput.Output)
self.ThresholdedInput.connect(self._opThreshold.Output)
def __init__(self, *args, **kwargs):
super(OpFormattedDataExport, self).__init__(*args, **kwargs)
self._dirty = True
opSubRegion = OpSubRegion(parent=self)
opSubRegion.Input.connect(self.Input)
self._opSubRegion = opSubRegion
# If normalization parameters are provided, we inject a 'drange'
# metadata item for downstream operators/gui to use.
opDrangeInjection = OpMetadataInjector(parent=self)
opDrangeInjection.Input.connect(opSubRegion.Output)
self._opDrangeInjection = opDrangeInjection
# Normalization and dtype conversion are performed in one step
# using an OpPixelOperator.
opNormalizeAndConvert = OpPixelOperator(parent=self)
opNormalizeAndConvert.Input.connect(opDrangeInjection.Output)
self._opNormalizeAndConvert = opNormalizeAndConvert
# ConvertedImage shows the full result but WITHOUT axis reordering.
self.ConvertedImage.connect(self._opNormalizeAndConvert.Output)
opReorderAxes = OpReorderAxes(parent=self)
opReorderAxes.Input.connect(opNormalizeAndConvert.Output)
self._opReorderAxes = opReorderAxes
self.ImageToExport.connect(opReorderAxes.Output)
self._opExportSlot = OpExportSlot(parent=self)
self._opExportSlot.Input.connect(opReorderAxes.Output)
self._opExportSlot.OutputFormat.connect(self.OutputFormat)
self.ExportPath.connect(self._opExportSlot.ExportPath)
self.FormatSelectionErrorMsg.connect(
self._opExportSlot.FormatSelectionErrorMsg)
self.progressSignal = self._opExportSlot.progressSignal
def __init__(self, *args, **kwargs):
super(OpThresholdTwoLevels, self).__init__(*args, **kwargs)
self.opReorderInput = OpReorderAxes(parent=self)
self.opReorderInput.AxisOrder.setValue('tzyxc')
self.opReorderInput.Input.connect(self.InputImage)
# PROBABILITIES: Convert to float32
self.opConvertProbabilities = OpConvertDtype( parent=self )
self.opConvertProbabilities.ConversionDtype.setValue( np.float32 )
self.opConvertProbabilities.Input.connect( self.opReorderInput.Output )
# PROBABILITIES: Normalize drange to [0.0, 1.0]
self.opNormalizeProbabilities = OpPixelOperator( parent=self )
def normalize_inplace(a):
drange = self.opNormalizeProbabilities.Input.meta.drange
if drange is None or (drange[0] == 0.0 and drange[1] == 1.0):
return a
a[:] -= drange[0]
a[:] = a[:]/float(( drange[1] - drange[0] ))
return a
self.opNormalizeProbabilities.Input.connect( self.opConvertProbabilities.Output )
self.opNormalizeProbabilities.Function.setValue( normalize_inplace )
self.opSmoother = OpAnisotropicGaussianSmoothing5d(parent=self)
self.opSmoother.Sigmas.connect( self.SmootherSigma )
self.opSmoother.Input.connect( self.opNormalizeProbabilities.Output )
self.opSmootherCache = OpBlockedArrayCache(parent=self)
self.opSmootherCache.BlockShape.setValue((1, None, None, None, 1))
self.opSmootherCache.Input.connect( self.opSmoother.Output )
self.opCoreChannelSelector = OpSingleChannelSelector(parent=self)
self.opCoreChannelSelector.Index.connect( self.CoreChannel )
self.opCoreChannelSelector.Input.connect( self.opSmootherCache.Output )
self.opCoreThreshold = OpLabeledThreshold(parent=self)
self.opCoreThreshold.Method.setValue( ThresholdMethod.SIMPLE )
self.opCoreThreshold.FinalThreshold.connect( self.HighThreshold )
self.opCoreThreshold.Input.connect( self.opCoreChannelSelector.Output )
self.opCoreFilter = OpFilterLabels(parent=self)
self.opCoreFilter.BinaryOut.setValue(False)
self.opCoreFilter.MinLabelSize.connect( self.MinSize )
self.opCoreFilter.MaxLabelSize.connect( self.MaxSize )
self.opCoreFilter.Input.connect( self.opCoreThreshold.Output )
self.opFinalChannelSelector = OpSingleChannelSelector(parent=self)
self.opFinalChannelSelector.Index.connect( self.Channel )
self.opFinalChannelSelector.Input.connect( self.opSmootherCache.Output )
self.opSumInputs = OpMultiArrayMerger(parent=self) # see setupOutputs (below) for input connections
self.opSumInputs.MergingFunction.setValue( sum )
self.opFinalThreshold = OpLabeledThreshold(parent=self)
self.opFinalThreshold.Method.connect( self.CurOperator )
self.opFinalThreshold.FinalThreshold.connect( self.LowThreshold )
self.opFinalThreshold.GraphcutBeta.connect( self.Beta )
self.opFinalThreshold.CoreLabels.connect( self.opCoreFilter.Output )
self.opFinalThreshold.Input.connect( self.opSumInputs.Output )
self.opFinalFilter = OpFilterLabels(parent=self)
self.opFinalFilter.BinaryOut.setValue(False)
self.opFinalFilter.MinLabelSize.connect( self.MinSize )
self.opFinalFilter.MaxLabelSize.connect( self.MaxSize )
self.opFinalFilter.Input.connect( self.opFinalThreshold.Output )
self.opReorderOutput = OpReorderAxes(parent=self)
#self.opReorderOutput.AxisOrder.setValue('tzyxc') # See setupOutputs()
self.opReorderOutput.Input.connect(self.opFinalFilter.Output)
self.Output.connect( self.opReorderOutput.Output )
self.opCache = OpBlockedArrayCache(parent=self)
self.opCache.CompressionEnabled.setValue(True)
self.opCache.Input.connect( self.opReorderOutput.Output )
self.CachedOutput.connect( self.opCache.Output )
self.CleanBlocks.connect( self.opCache.CleanBlocks )
## Debug outputs
self.Smoothed.connect( self.opSmootherCache.Output )
self.InputChannel.connect( self.opFinalChannelSelector.Output )
self.SmallRegions.connect( self.opCoreThreshold.Output )
self.FilteredSmallLabels.connect( self.opCoreFilter.Output )
self.BeforeSizeFilter.connect( self.opFinalThreshold.Output )
# Since hysteresis thresholding creates the big regions and immediately discards the bad ones,
# we have to recreate it here if the user wants to view it as a debug layer
self.opBigRegionsThreshold = OpLabeledThreshold(parent=self)
self.opBigRegionsThreshold.Method.setValue( ThresholdMethod.SIMPLE )
self.opBigRegionsThreshold.FinalThreshold.connect( self.LowThreshold )
self.opBigRegionsThreshold.Input.connect( self.opFinalChannelSelector.Output )
self.BigRegions.connect( self.opBigRegionsThreshold.Output )
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