def __init__(self, topLevelOperatorView, shellRequestSignal, guiControlSignal, predictionSerializer ):
# Tell our base class which slots to monitor
labelSlots = LabelingGui.LabelingSlots()
labelSlots.labelInput = topLevelOperatorView.LabelInputs
labelSlots.labelOutput = topLevelOperatorView.LabelImages
labelSlots.labelEraserValue = topLevelOperatorView.opLabelPipeline.opLabelArray.eraser
labelSlots.labelDelete = topLevelOperatorView.opLabelPipeline.opLabelArray.deleteLabel
labelSlots.maxLabelValue = topLevelOperatorView.MaxLabelValue
labelSlots.labelsAllowed = topLevelOperatorView.LabelsAllowedFlags
# We provide our own UI file (which adds an extra control for interactive mode)
labelingDrawerUiPath = os.path.split(__file__)[0] + '/countingDrawer.ui'
# Base class init
super(CountingGui, self).__init__( labelSlots, topLevelOperatorView, labelingDrawerUiPath )
self.op = topLevelOperatorView
self.topLevelOperatorView = topLevelOperatorView
self.shellRequestSignal = shellRequestSignal
self.guiControlSignal = guiControlSignal
self.predictionSerializer = predictionSerializer
self.interactiveModeActive = False
self._currentlySavingPredictions = False
self.labelingDrawerUi.savePredictionsButton.clicked.connect(self.onSavePredictionsButtonClicked)
self.labelingDrawerUi.savePredictionsButton.setIcon( QIcon(ilastikIcons.Save) )
self.labelingDrawerUi.liveUpdateButton.setEnabled(False)
self.labelingDrawerUi.liveUpdateButton.setIcon( QIcon(ilastikIcons.Play) )
self.labelingDrawerUi.liveUpdateButton.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.labelingDrawerUi.liveUpdateButton.toggled.connect( self.toggleInteractive )
self.topLevelOperatorView.MaxLabelValue.notifyDirty( bind(self.handleLabelSelectionChange) )
self._initShortcuts()
try:
self.render = True
self._renderedLayers = {} # (layer name, label number)
self._renderMgr = RenderingManager(
renderer=self.editor.view.qvtk.renderer,
qvtk=self.editor.view.qvtk)
except:
self.render = False
self.initCounting()
class CountingGui(LabelingGui):
###########################################
### AppletGuiInterface Concrete Methods ###
###########################################
def centralWidget( self ):
return self
def reset(self):
# Base class first
super(CountingGui, self).reset()
# Ensure that we are NOT in interactive mode
self.labelingDrawerUi.liveUpdateButton.setChecked(False)
self._viewerControlUi.checkShowPredictions.setChecked(False)
self._viewerControlUi.checkShowSegmentation.setChecked(False)
self.toggleInteractive(False)
def viewerControlWidget(self):
return self._viewerControlUi
###########################################
###########################################
@traceLogged(traceLogger)
def __init__(self, topLevelOperatorView, shellRequestSignal, guiControlSignal, predictionSerializer ):
# Tell our base class which slots to monitor
labelSlots = LabelingGui.LabelingSlots()
labelSlots.labelInput = topLevelOperatorView.LabelInputs
labelSlots.labelOutput = topLevelOperatorView.LabelImages
labelSlots.labelEraserValue = topLevelOperatorView.opLabelPipeline.opLabelArray.eraser
labelSlots.labelDelete = topLevelOperatorView.opLabelPipeline.opLabelArray.deleteLabel
labelSlots.maxLabelValue = topLevelOperatorView.MaxLabelValue
labelSlots.labelsAllowed = topLevelOperatorView.LabelsAllowedFlags
# We provide our own UI file (which adds an extra control for interactive mode)
labelingDrawerUiPath = os.path.split(__file__)[0] + '/countingDrawer.ui'
# Base class init
super(CountingGui, self).__init__( labelSlots, topLevelOperatorView, labelingDrawerUiPath )
self.op = topLevelOperatorView
self.topLevelOperatorView = topLevelOperatorView
self.shellRequestSignal = shellRequestSignal
self.guiControlSignal = guiControlSignal
self.predictionSerializer = predictionSerializer
self.interactiveModeActive = False
self._currentlySavingPredictions = False
self.labelingDrawerUi.savePredictionsButton.clicked.connect(self.onSavePredictionsButtonClicked)
self.labelingDrawerUi.savePredictionsButton.setIcon( QIcon(ilastikIcons.Save) )
self.labelingDrawerUi.liveUpdateButton.setEnabled(False)
self.labelingDrawerUi.liveUpdateButton.setIcon( QIcon(ilastikIcons.Play) )
self.labelingDrawerUi.liveUpdateButton.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.labelingDrawerUi.liveUpdateButton.toggled.connect( self.toggleInteractive )
self.topLevelOperatorView.MaxLabelValue.notifyDirty( bind(self.handleLabelSelectionChange) )
self._initShortcuts()
try:
self.render = True
self._renderedLayers = {} # (layer name, label number)
self._renderMgr = RenderingManager(
renderer=self.editor.view.qvtk.renderer,
qvtk=self.editor.view.qvtk)
except:
self.render = False
self.initCounting()
def initCounting(self):
#=======================================================================
# Init Dotting interface
#=======================================================================
self.dotcrosshairController=DotCrosshairController(self.editor.brushingModel,self.editor.imageViews)
self.editor.crosshairControler=self.dotcrosshairController
self.dotController=DotController(self.editor.imageScenes[2],self.editor.brushingControler)
self.editor.brushingInterpreter = DotInterpreter(self.editor.navCtrl,self.editor.brushingControler,self.dotController)
self.dotIntepreter=self.editor.brushingInterpreter
#=======================================================================
# Init Label Control Ui Custom setup
#=======================================================================
self._viewerControlUi.label.setVisible(False)
self._viewerControlUi.checkShowPredictions.setVisible(False)
self._viewerControlUi.checkShowSegmentation.setVisible(False)
self._addNewLabel()
self._addNewLabel()
self._labelControlUi.brushSizeComboBox.setEnabled(False)
self._labelControlUi.brushSizeCaption.setEnabled(False)
self.selectLabel(0)
#=======================================================================
# Init labeling Drawer Ui Custom setup
#=======================================================================
#labels for foreground and background
self.labelingDrawerUi.labelListModel.makeRowPermanent(0)
self.labelingDrawerUi.labelListModel.makeRowPermanent(1)
self.labelingDrawerUi.labelListModel[0].name = "Foreground"
self.labelingDrawerUi.labelListModel[1].name = "Background"
self.labelingDrawerUi.labelListView.shrinkToMinimum()
self.labelingDrawerUi.CountText.setReadOnly(True)
# self.labelingDrawerUi.SigmaLine.setText(str(self.op.opTrain.Sigma.value))
# self.labelingDrawerUi.CBox.setRange(0,1000)
# self.labelingDrawerUi.CBox.setKeyboardTracking(False)
# self.labelingDrawerUi.EpsilonBox.setKeyboardTracking(False)
# self.labelingDrawerUi.EpsilonBox.setDecimals(6)
# self.labelingDrawerUi.NtreesBox.setKeyboardTracking(False)
# self.labelingDrawerUi.MaxDepthBox.setKeyboardTracking(False)
#
# for option in self.op.options:
# if "req" in option.keys():
# try:
# import imp
# for req in option["req"]:
# imp.find_module(req)
# except:
# continue
# #values=[v for k,v in option.items() if k not in ["gui", "req"]]
# self.labelingDrawerUi.SVROptions.addItem(option["method"], (option,))
#
self._setUIParameters()
self._connectUIParameters()
#=======================================================================
# Init Boxes Interface
#=======================================================================
#if not hasattr(self._labelControlUi, "boxListModel"):
self.labelingDrawerUi.boxListModel=BoxListModel()
self.labelingDrawerUi.boxListView.setModel(self.labelingDrawerUi.boxListModel)
self.labelingDrawerUi.boxListModel.elementSelected.connect(self._onBoxSelected)
self.labelingDrawerUi.boxListModel.boxRemoved.connect(self._removeBox)
# ###FIXME: Only for debug
def updateSum(*args, **kw):
print "updatingSum"
density = self.op.OutputSum.value
strdensity = "{0:.2f}".format(density)
self._labelControlUi.CountText.setText(strdensity)
self.op.Density.notifyDirty(updateSum)
mainwin=self
self.density5d=Op5ifyer(graph=self.op.graph) #FIXME: Hack , get the proper reference to the graph
self.density5d.input.connect(self.op.Density)
self.boxController=BoxController(mainwin.editor.imageScenes[2],self.density5d.output,self.labelingDrawerUi.boxListModel)
self.boxIntepreter=BoxInterpreter(mainwin.editor.navInterpret,mainwin.editor.posModel,self.boxController,mainwin.centralWidget())
self.rubberbandClickReporter = self.boxIntepreter
self.rubberbandClickReporter.leftClickReleased.connect( self.handleBoxQuery )
self.rubberbandClickReporter.leftClickReleased.connect(self._addNewBox)
self.navigationIntepreterDefault=self.editor.navInterpret
self.boxController.fixedBoxesChanged.connect(self._handleBoxConstraints)
def _connectUIParameters(self):
#=======================================================================
# Gui to operator connections
#=======================================================================
self._changedSigma = True
#Debug interface only available otadvanced users
self.labelingDrawerUi.DebugButton.pressed.connect(self._debug)
#elf._updateSVROptions()
self.labelingDrawerUi.boxListView.resetEmptyMessage("no boxes defined yet")
self.labelingDrawerUi.SVROptions.currentIndexChanged.connect(self._updateSVROptions)
self.labelingDrawerUi.CBox.valueChanged.connect(self._updateC)
def _editingSigma(text):
self._changedSigma =True
self.labelingDrawerUi.SigmaLine.textChanged.connect(_editingSigma)
self.labelingDrawerUi.SigmaLine.editingFinished.connect(self._updateSigma)
self.labelingDrawerUi.EpsilonBox.valueChanged.connect(self._updateEpsilon)
self.labelingDrawerUi.MaxDepthBox.valueChanged.connect(self._updateMaxDepth)
self.labelingDrawerUi.NtreesBox.valueChanged.connect(self._updateNtrees)
#=======================================================================
# Operators to Gui connections
#=======================================================================
self._registerOperatorsToGuiCallbacks()
#=======================================================================
# Initialize Values
#=======================================================================
self._updateSigma()
self._updateNtrees()
self._updateMaxDepth()
def _registerOperatorsToGuiCallbacks(self):
op=self.op.opTrain
gui=self.labelingDrawerUi
CallToGui(op.Ntrees,gui.NtreesBox.setValue)
CallToGui(op.MaxDepth,gui.MaxDepthBox.setValue)
CallToGui(op.C,gui.CBox.setValue)
def _setsigma(floatList):
ss=""
for el in floatList:
ss+="%.1f "%el
ss=ss[:-1]
gui.SigmaLine.setText(QString(ss))
CallToGui(op.Sigma,_setsigma)
CallToGui(op.Epsilon,gui.EpsilonBox.setValue)
def _setoption(option):
ss = option["method"]
index=gui.SVROptions.findText(ss)
gui.SVROptions.setCurrentIndex(index)
CallToGui(op.SelectedOption,_setoption)
def _setUIParameters(self):
self.labelingDrawerUi.SigmaLine.setText(str(self.op.opTrain.Sigma.value))
self.labelingDrawerUi.CBox.setRange(0,1000)
self.labelingDrawerUi.CBox.setKeyboardTracking(False)
self.labelingDrawerUi.EpsilonBox.setKeyboardTracking(False)
self.labelingDrawerUi.EpsilonBox.setDecimals(6)
self.labelingDrawerUi.NtreesBox.setKeyboardTracking(False)
self.labelingDrawerUi.MaxDepthBox.setKeyboardTracking(False)
for option in self.op.options:
if "req" in option.keys():
try:
import imp
for req in option["req"]:
imp.find_module(req)
except:
continue
#values=[v for k,v in option.items() if k not in ["gui", "req"]]
self.labelingDrawerUi.SVROptions.addItem(option["method"], (option,))
if self.op.classifier_cache._value and len(self.op.classifier_cache._value) > 0:
#use parameters from cached classifier
params = self.op.classifier_cache.Output.value.get_params()
Sigma = params["Sigma"]
Epsilon = params["epsilon"]
C = params["C"]
Ntrees = params["ntrees"]
MaxDepth = params["maxdepth"]
_ind = self.labelingDrawerUi.SVROptions.findText(params["method"])
else:
#read parameters from opTrain Operator
Sigma = self.op.opTrain.Sigma.value
Epsilon = self.op.opTrain.Epsilon.value
C = self.op.opTrain.C.value
Ntrees = self.op.opTrain.Ntrees.value
MaxDepth = self.op.opTrain.MaxDepth.value
_ind = self.labelingDrawerUi.SVROptions.findText(self.op.opTrain.SelectedOption.value["method"])
self.labelingDrawerUi.SigmaLine.setText(" ".join(str(s) for s in Sigma))
self.labelingDrawerUi.EpsilonBox.setValue(Epsilon)
self.labelingDrawerUi.CBox.setValue(C)
self.labelingDrawerUi.NtreesBox.setValue(Ntrees)
self.labelingDrawerUi.MaxDepthBox.setValue(MaxDepth)
self.labelingDrawerUi.SVROptions.setCurrentIndex(_ind)
self._hideParameters()
def _updateMaxDepth(self):
self.op.opTrain.MaxDepth.setValue(self.labelingDrawerUi.MaxDepthBox.value())
def _updateNtrees(self):
self.op.opTrain.Ntrees.setValue(self.labelingDrawerUi.NtreesBox.value())
def _hideParameters(self):
_ind = self.labelingDrawerUi.SVROptions.currentIndex()
option = self.labelingDrawerUi.SVROptions.itemData(_ind).toPyObject()[0]
if "svr" not in option["gui"]:
self.labelingDrawerUi.gridLayout_2.setVisible(False)
else:
self.labelingDrawerUi.gridLayout_2.setVisible(True)
if "rf" not in option["gui"]:
self.labelingDrawerUi.rf_panel.setVisible(False)
else:
self.labelingDrawerUi.rf_panel.setVisible(True)
#def _updateOverMult(self):
# self.op.opTrain.OverMult.setValue(self.labelingDrawerUi.OverBox.value())
#def _updateUnderMult(self):
# self.op.opTrain.UnderMult.setValue(self.labelingDrawerUi.UnderBox.value())
def _updateC(self):
self.op.opTrain.C.setValue(self.labelingDrawerUi.CBox.value())
def _updateSigma(self):
if self._changedSigma:
sigma = [float(n) for n in
self._labelControlUi.SigmaLine.text().split(" ")]
self.editor.crosshairControler.setSigma(sigma[0])
self.dotController.setDotsRadius(sigma[0]*2)
self.op.opTrain.Sigma.setValue(sigma)
self._changedSigma = False
def _updateEpsilon(self):
self.op.opTrain.Epsilon.setValue(self.labelingDrawerUi.EpsilonBox.value())
def _updateSVROptions(self):
index = self.labelingDrawerUi.SVROptions.currentIndex()
option = self.labelingDrawerUi.SVROptions.itemData(index).toPyObject()[0]
self.op.opTrain.SelectedOption.setValue(option)
self._hideFixable(option)
self._hideParameters()
def _hideFixable(self,option):
if 'method' in option and option['method']=='rf-sklearn':
self.labelingDrawerUi.boxListView.allowFixIcon=False
self.labelingDrawerUi.boxListView.allowFixValues=False
elif 'method' in option and option['method']=='svrBoxed-gurobi':
self.labelingDrawerUi.boxListView.allowFixIcon=True
def _handleBoxConstraints(self, constr):
self.op.opTrain.BoxConstraints.setValue(constr)
#boxes = self.boxController._currentBoxesList
def _debug(self):
import sitecustomize
sitecustomize.debug_trace()
@traceLogged(traceLogger)
def initViewerControlUi(self):
localDir = os.path.split(__file__)[0]
self._viewerControlUi = uic.loadUi( os.path.join( localDir, "viewerControls.ui" ) )
# Connect checkboxes
def nextCheckState(checkbox):
checkbox.setChecked( not checkbox.isChecked() )
self._viewerControlUi.checkShowPredictions.clicked.connect( self.handleShowPredictionsClicked )
self._viewerControlUi.checkShowSegmentation.clicked.connect( self.handleShowSegmentationClicked )
# The editor's layerstack is in charge of which layer movement buttons are enabled
model = self.editor.layerStack
self._viewerControlUi.viewerControls.setupConnections(model)
def _initShortcuts(self):
mgr = ShortcutManager()
shortcutGroupName = "Predictions"
togglePredictions = QShortcut( QKeySequence("p"), self, member=self._viewerControlUi.checkShowPredictions.click )
mgr.register( shortcutGroupName,
"Toggle Prediction Layer Visibility",
togglePredictions,
self._viewerControlUi.checkShowPredictions )
toggleSegmentation = QShortcut( QKeySequence("s"), self, member=self._viewerControlUi.checkShowSegmentation.click )
mgr.register( shortcutGroupName,
"Toggle Segmentaton Layer Visibility",
toggleSegmentation,
self._viewerControlUi.checkShowSegmentation )
toggleLivePredict = QShortcut( QKeySequence("l"), self, member=self.labelingDrawerUi.liveUpdateButton.toggle )
mgr.register( shortcutGroupName,
"Toggle Live Prediction Mode",
toggleLivePredict,
self.labelingDrawerUi.liveUpdateButton )
def _setup_contexts(self, layer):
def callback(pos, clayer=layer):
name = clayer.name
if name in self._renderedLayers:
label = self._renderedLayers.pop(name)
self._renderMgr.removeObject(label)
self._update_rendering()
else:
label = self._renderMgr.addObject()
self._renderedLayers[clayer.name] = label
self._update_rendering()
if self.render:
layer.contexts.append(('Toggle 3D rendering', callback))
@traceLogged(traceLogger)
def setupLayers(self):
"""
Called by our base class when one of our data slots has changed.
This function creates a layer for each slot we want displayed in the volume editor.
"""
# Base class provides the label layer.
layers = super(CountingGui, self).setupLayers()
# Add each of the predictions
labels = self.labelListData
slots = {'Prediction' : self.op.Density}
for name, slot in slots.items():
if slot.ready():
from volumina import colortables
layer = ColortableLayer(LazyflowSource(slot), colorTable = colortables.jet(), normalize = 'auto')
layer.name = name
layer.visible = self.labelingDrawerUi.liveUpdateButton.isChecked()
#layer.visibleChanged.connect(self.updateShowPredictionCheckbox)
layers.append(layer)
boxlabelsrc = LazyflowSinkSource(self.op.BoxLabelImages,self.op.BoxLabelInputs )
boxlabellayer = ColortableLayer(boxlabelsrc, colorTable = self._colorTable16, direct = False)
boxlabellayer.name = "boxLabels"
boxlabellayer.opacity = 1.0
boxlabellayer.visibleChanged.connect(self.boxController.changeBoxesVisibility)
boxlabellayer.opacityChanged.connect(self.boxController.changeBoxesOpacity)
layers.append(boxlabellayer)
self.boxlabelsrc = boxlabelsrc
inputDataSlot = self.topLevelOperatorView.InputImages
if inputDataSlot.ready():
inputLayer = self.createStandardLayerFromSlot( inputDataSlot )
inputLayer.name = "Input Data"
inputLayer.visible = True
inputLayer.opacity = 1.0
def toggleTopToBottom():
index = self.layerstack.layerIndex( inputLayer )
self.layerstack.selectRow( index )
if index == 0:
self.layerstack.moveSelectedToBottom()
else:
self.layerstack.moveSelectedToTop()
inputLayer.shortcutRegistration = (
"Prediction Layers",
"Bring Input To Top/Bottom",
QShortcut( QKeySequence("i"), self.viewerControlWidget(), toggleTopToBottom),
inputLayer )
layers.append(inputLayer)
self.handleLabelSelectionChange()
return layers
@traceLogged(traceLogger)
def toggleInteractive(self, checked):
"""
If enable
"""
logger.debug("toggling interactive mode to '%r'" % checked)
if checked==True:
if not self.topLevelOperatorView.FeatureImages.ready() \
or self.topLevelOperatorView.FeatureImages.meta.shape==None:
self.labelingDrawerUi.liveUpdateButton.setChecked(False)
mexBox=QMessageBox()
mexBox.setText("There are no features selected ")
mexBox.exec_()
return
self.labelingDrawerUi.savePredictionsButton.setEnabled(not checked)
self.topLevelOperatorView.FreezePredictions.setValue( not checked )
# Auto-set the "show predictions" state according to what the user just clicked.
if checked:
self._viewerControlUi.checkShowPredictions.setChecked( True )
self.handleShowPredictionsClicked()
# If we're changing modes, enable/disable our controls and other applets accordingly
if self.interactiveModeActive != checked:
if checked:
self.labelingDrawerUi.labelListView.allowDelete = False
#self.labelingDrawerUi.AddLabelButton.setEnabled( False )
else:
self.labelingDrawerUi.labelListView.allowDelete = True
#self.labelingDrawerUi.AddLabelButton.setEnabled( True )
self.interactiveModeActive = checked
@pyqtSlot()
@traceLogged(traceLogger)
def handleShowPredictionsClicked(self):
checked = self._viewerControlUi.checkShowPredictions.isChecked()
for layer in self.layerstack:
if "Prediction" in layer.name:
layer.visible = checked
@pyqtSlot()
@traceLogged(traceLogger)
def handleShowSegmentationClicked(self):
checked = self._viewerControlUi.checkShowSegmentation.isChecked()
for layer in self.layerstack:
if "Segmentation" in layer.name:
layer.visible = checked
@pyqtSlot()
@traceLogged(traceLogger)
def updateShowPredictionCheckbox(self):
predictLayerCount = 0
visibleCount = 0
for layer in self.layerstack:
if "Prediction" in layer.name:
predictLayerCount += 1
if layer.visible:
visibleCount += 1
if visibleCount == 0:
self._viewerControlUi.checkShowPredictions.setCheckState(Qt.Unchecked)
elif predictLayerCount == visibleCount:
self._viewerControlUi.checkShowPredictions.setCheckState(Qt.Checked)
else:
self._viewerControlUi.checkShowPredictions.setCheckState(Qt.PartiallyChecked)
@pyqtSlot()
@traceLogged(traceLogger)
def updateShowSegmentationCheckbox(self):
segLayerCount = 0
visibleCount = 0
for layer in self.layerstack:
if "Segmentation" in layer.name:
segLayerCount += 1
if layer.visible:
visibleCount += 1
if visibleCount == 0:
self._viewerControlUi.checkShowSegmentation.setCheckState(Qt.Unchecked)
elif segLayerCount == visibleCount:
self._viewerControlUi.checkShowSegmentation.setCheckState(Qt.Checked)
else:
self._viewerControlUi.checkShowSegmentation.setCheckState(Qt.PartiallyChecked)
@pyqtSlot()
@threadRouted
@traceLogged(traceLogger)
def handleLabelSelectionChange(self):
enabled = False
if self.topLevelOperatorView.MaxLabelValue.ready():
enabled = True
enabled &= self.topLevelOperatorView.MaxLabelValue.value >= 2
enabled &= numpy.all(numpy.asarray(self.topLevelOperatorView.CachedFeatureImages.meta.shape) > 0)
# FIXME: also check that each label has scribbles?
self.labelingDrawerUi.savePredictionsButton.setEnabled(enabled)
self.labelingDrawerUi.liveUpdateButton.setEnabled(enabled)
self._viewerControlUi.checkShowPredictions.setEnabled(enabled)
self._viewerControlUi.checkShowSegmentation.setEnabled(enabled)
@pyqtSlot()
@traceLogged(traceLogger)
def onSavePredictionsButtonClicked(self):
"""
The user clicked "Train and Predict".
Handle this event by asking the topLevelOperatorView for a prediction over the entire output region.
"""
# The button does double-duty as a cancel button while predictions are being stored
if self._currentlySavingPredictions:
self.predictionSerializer.cancel()
else:
# Compute new predictions as needed
predictionsFrozen = self.topLevelOperatorView.FreezePredictions.value
self.topLevelOperatorView.FreezePredictions.setValue(False)
self._currentlySavingPredictions = True
originalButtonText = "Full Volume Predict and Save"
self.labelingDrawerUi.savePredictionsButton.setText("Cancel Full Predict")
@traceLogged(traceLogger)
def saveThreadFunc():
logger.info("Starting full volume save...")
# Disable all other applets
self.guiControlSignal.emit( ControlCommand.DisableUpstream )
self.guiControlSignal.emit( ControlCommand.DisableDownstream )
def disableAllInWidgetButName(widget, exceptName):
for child in widget.children():
if child.findChild( QPushButton, exceptName) is None:
child.setEnabled(False)
else:
disableAllInWidgetButName(child, exceptName)
# Disable everything in our drawer *except* the cancel button
disableAllInWidgetButName(self.labelingDrawerUi, "savePredictionsButton")
# But allow the user to cancel the save
self.labelingDrawerUi.savePredictionsButton.setEnabled(True)
# First, do a regular save.
# During a regular save, predictions are not saved to the project file.
# (It takes too much time if the user only needs the classifier.)
self.shellRequestSignal.emit( ShellRequest.RequestSave )
# Enable prediction storage and ask the shell to save the project again.
# (This way the second save will occupy the whole progress bar.)
self.predictionSerializer.predictionStorageEnabled = True
self.shellRequestSignal.emit( ShellRequest.RequestSave )
self.predictionSerializer.predictionStorageEnabled = False
# Restore original states (must use events for UI calls)
self.thunkEventHandler.post(self.labelingDrawerUi.savePredictionsButton.setText, originalButtonText)
self.topLevelOperatorView.FreezePredictions.setValue(predictionsFrozen)
self._currentlySavingPredictions = False
# Re-enable our controls
def enableAll(widget):
for child in widget.children():
if isinstance( child, QWidget ):
child.setEnabled(True)
enableAll(child)
enableAll(self.labelingDrawerUi)
# Re-enable all other applets
self.guiControlSignal.emit( ControlCommand.Pop )
self.guiControlSignal.emit( ControlCommand.Pop )
logger.info("Finished full volume save.")
saveThread = threading.Thread(target=saveThreadFunc)
saveThread.start()
def _getNext(self, slot, parentFun, transform=None):
numLabels = self.labelListData.rowCount()
value = slot.value
if numLabels < len(value):
result = value[numLabels]
if transform is not None:
result = transform(result)
return result
else:
return parentFun()
def _onLabelChanged(self, parentFun, mapf, slot):
parentFun()
new = map(mapf, self.labelListData)
old = slot.value
slot.setValue(_listReplace(old, new))
def _onLabelRemoved(self, parent, start, end):
super(CountingGui, self)._onLabelRemoved(parent, start, end)
op = self.topLevelOperatorView
for slot in (op.LabelNames, op.LabelColors, op.PmapColors):
value = slot.value
value.pop(start)
slot.setValue(value)
def getNextLabelName(self):
return self._getNext(self.topLevelOperatorView.LabelNames,
super(CountingGui, self).getNextLabelName)
def getNextLabelColor(self):
return self._getNext(
self.topLevelOperatorView.LabelColors,
super(CountingGui, self).getNextLabelColor,
lambda x: QColor(*x)
)
def getNextPmapColor(self):
return self._getNext(
self.topLevelOperatorView.PmapColors,
super(CountingGui, self).getNextPmapColor,
lambda x: QColor(*x)
)
def onLabelNameChanged(self):
self._onLabelChanged(super(CountingGui, self).onLabelNameChanged,
lambda l: l.name,
self.topLevelOperatorView.LabelNames)
def onLabelColorChanged(self):
self._onLabelChanged(super(CountingGui, self).onLabelColorChanged,
lambda l: (l.brushColor().red(),
l.brushColor().green(),
l.brushColor().blue()),
self.topLevelOperatorView.LabelColors)
def onPmapColorChanged(self):
self._onLabelChanged(super(CountingGui, self).onPmapColorChanged,
lambda l: (l.pmapColor().red(),
l.pmapColor().green(),
l.pmapColor().blue()),
self.topLevelOperatorView.PmapColors)
def _update_rendering(self):
if not self.render:
return
shape = self.topLevelOperatorView.InputImages.meta.shape[1:4]
time = self.editor._posModel.slicingPos5D[0]
if not self._renderMgr.ready:
self._renderMgr.setup(shape)
layernames = set(layer.name for layer in self.layerstack)
self._renderedLayers = dict((k, v) for k, v in self._renderedLayers.iteritems()
if k in layernames)
newvolume = numpy.zeros(shape, dtype=numpy.uint8)
for layer in self.layerstack:
try:
label = self._renderedLayers[layer.name]
except KeyError:
continue
for ds in layer.datasources:
vol = ds.dataSlot.value[time, ..., 0]
indices = numpy.where(vol != 0)
newvolume[indices] = label
self._renderMgr.volume = newvolume
self._update_colors()
self._renderMgr.update()
def _update_colors(self):
for layer in self.layerstack:
try:
label = self._renderedLayers[layer.name]
except KeyError:
continue
color = layer.tintColor
color = (color.red(), color.green() , color.blue() )
self._renderMgr.setColor(label, color)
def _gui_setNavigation(self):
self._labelControlUi.brushSizeComboBox.setEnabled(False)
self._labelControlUi.brushSizeCaption.setEnabled(False)
self._labelControlUi.arrowToolButton.setChecked(True)
# if not hasattr(self, "rubberbandClickReporter"):
#
# self.rubberbandClickReporter = self.boxIntepreter
# self.rubberbandClickReporter.leftClickReleased.connect( self.handleBoxQuery )
# self.editor.setNavigationInterpreter(self.rubberbandClickReporter)
def _gui_setBrushing(self):
# self._labelControlUi.brushSizeComboBox.setEnabled(False)
# self._labelControlUi.brushSizeCaption.setEnabled(False)
# Make sure the paint button is pressed
self._labelControlUi.paintToolButton.setChecked(True)
# Show the brush size control and set its caption
self._labelControlUi.brushSizeCaption.setText("Size:")
# Make sure the GUI reflects the correct size
#self._labelControlUi.brushSizeComboBox.setCurrentIndex(0)
def _gui_setBox(self):
self._labelControlUi.brushSizeComboBox.setEnabled(False)
self._labelControlUi.brushSizeCaption.setEnabled(False)
self._labelControlUi.arrowToolButton.setChecked(False)
#self._labelControlUi.boxToolButton.setChecked(True)
def _onBoxChanged(self,parentFun, mapf):
parentFun()
new = map(mapf, self.labelListData)
def _changeInteractionMode( self, toolId ):
"""
Implement the GUI's response to the user selecting a new tool.
"""
QApplication.restoreOverrideCursor()
for v in self.editor.crosshairControler._imageViews:
v._crossHairCursor.enabled=True
# Uncheck all the other buttons
for tool, button in self.toolButtons.items():
if tool != toolId:
button.setChecked(False)
# If we have no editor, we can't do anything yet
if self.editor is None:
return
# The volume editor expects one of two specific names
modeNames = { Tool.Navigation : "navigation",
Tool.Paint : "brushing",
Tool.Erase : "brushing",
Tool.Box : "navigation"
}
# If the user can't label this image, disable the button and say why its disabled
labelsAllowed = False
labelsAllowedSlot = self._labelingSlots.labelsAllowed
if labelsAllowedSlot.ready():
labelsAllowed = labelsAllowedSlot.value
if hasattr(self._labelControlUi, "AddLabelButton"):
self._labelControlUi.AddLabelButton.setEnabled(labelsAllowed and self.maxLabelNumber > self._labelControlUi.labelListModel.rowCount())
if labelsAllowed:
self._labelControlUi.AddLabelButton.setText("Add Label")
else:
self._labelControlUi.AddLabelButton.setText("(Labeling Not Allowed)")
e = labelsAllowed & (self._labelControlUi.labelListModel.rowCount() > 0)
self._gui_enableLabeling(e)
if labelsAllowed:
# Update the applet bar caption
if toolId == Tool.Navigation:
# update GUI
self.editor.brushingModel.setBrushSize(0)
self.editor.setNavigationInterpreter(NavigationInterpreter(self.editor.navCtrl))
self._gui_setNavigation()
elif toolId == Tool.Paint:
# If necessary, tell the brushing model to stop erasing
if self.editor.brushingModel.erasing:
self.editor.brushingModel.disableErasing()
# Set the brushing size
if self.editor.brushingModel.drawnNumber==1:
brushSize = 1
self.editor.brushingModel.setBrushSize(brushSize)
# update GUI
self._gui_setBrushing()
elif toolId == Tool.Erase:
# If necessary, tell the brushing model to start erasing
if not self.editor.brushingModel.erasing:
self.editor.brushingModel.setErasing()
# Set the brushing size
eraserSize = self.brushSizes[self.eraserSizeIndex]
self.editor.brushingModel.setBrushSize(eraserSize)
# update GUI
self._gui_setErasing()
elif toolId == Tool.Box:
for v in self.editor.crosshairControler._imageViews:
v._crossHairCursor.enabled=False
QApplication.setOverrideCursor(Qt.CrossCursor)
self.editor.brushingModel.setBrushSize(0)
self.editor.setNavigationInterpreter(self.boxIntepreter)
self._gui_setBox()
self.editor.setInteractionMode( modeNames[toolId] )
self._toolId = toolId
def _initLabelUic(self, drawerUiPath):
super(CountingGui, self)._initLabelUic(drawerUiPath)
#self._labelControlUi.boxToolButton.setCheckable(True)
#self._labelControlUi.boxToolButton.clicked.connect( lambda checked: self._handleToolButtonClicked(checked,
# Tool.Box) )
#self.toolButtons[Tool.Box] = self._labelControlUi.boxToolButton
if hasattr(self._labelControlUi, "AddBoxButton"):
self._labelControlUi.AddBoxButton.setIcon( QIcon(ilastikIcons.AddSel) )
self._labelControlUi.AddBoxButton.clicked.connect( bind(self.onAddNewBoxButtonClicked) )
def onAddNewBoxButtonClicked(self):
self._changeInteractionMode(Tool.Box)
# qcolor=self._getNextBoxColor()
# self.boxController.currentColor=qcolor
self.labelingDrawerUi.boxListView.resetEmptyMessage("Draw the box on the image")
def _addNewBox(self):
# pass
#Fixme: The functionality should maybe removed from here
newRow = self.labelingDrawerUi.boxListModel.rowCount()-1
newColorIndex = self._labelControlUi.boxListModel.index(newRow, 0)
# qcolor=self._getNextBoxColor()
# self.boxController.currentColor=qcolor
# Call the 'changed' callbacks immediately to initialize any listeners
#self.onLabelNameChanged()
#self.onLabelColorChanged()
#self.onPmapColorChanged()
def _removeBox(self,index):
#handled by the boxController
pass
#self.boxController.deleteItem(index)
def _onBoxSelected(self, row):
print "switching to box=%r" % (self._labelControlUi.boxListModel[row])
print "row = ",row
logger.debug("switching to label=%r" % (self._labelControlUi.boxListModel[row]))
# If the user is selecting a label, he probably wants to be in paint mode
self._changeInteractionMode(Tool.Box)
print len(self.boxController._currentBoxesList)
self.boxController.selectBoxItem(row)
@traceLogged(traceLogger)
def onBoxListDataChanged(self, topLeft, bottomRight):
pass
# """Handle changes to the label list selections."""
# firstRow = topLeft.row()
# lastRow = bottomRight.row()
#
# firstCol = topLeft.column()
# lastCol = bottomRight.column()
#
# # We only care about the color column
# if firstCol <= 0 <= lastCol:
# assert(firstRow == lastRow) # Only one data item changes at a time
#
# #in this case, the actual data (for example color) has changed
# color = self._labelControlUi.boxListModel[firstRow].brushColor()
# self._colorTable16[firstRow+1] = color.rgba()
# self.editor.brushingModel.setBrushColor(color)
#
# # Update the label layer colortable to match the list entry
# labellayer = self._getLabelLayer()
# if labellayer is not None:
# labellayer.colorTable = self._colorTable16
def _onLabelSelected(self, row):
print "switching to label=%r" % (self._labelControlUi.labelListModel[row])
logger.debug("switching to label=%r" % (self._labelControlUi.labelListModel[row]))
# If the user is selecting a label, he probably wants to be in paint mode
self._changeInteractionMode(Tool.Paint)
#+1 because first is transparent
#FIXME: shouldn't be just row+1 here
self.toolButtons[Tool.Paint].setEnabled(True)
#elf.toolButtons[Tool.Box].setEnabled(False)
self.toolButtons[Tool.Paint].click()
self.editor.brushingModel.setDrawnNumber(row+1)
brushColor = self._labelControlUi.labelListModel[row].brushColor()
self.editor.brushingModel.setBrushColor( brushColor )
if row==0: #foreground
self._cachedBrushSizeIndex= self._labelControlUi.brushSizeComboBox.currentIndex()
self._labelControlUi.brushSizeComboBox.setEnabled(False)
self._labelControlUi.brushSizeComboBox.setCurrentIndex(0)
else:
if not hasattr(self, "_cachedBrushSizeIndex"):
self._cachedBrushSizeIndex=0
self._labelControlUi.brushSizeComboBox.setCurrentIndex(self._cachedBrushSizeIndex)
def handleBoxQuery(self, position5d_start, position5d_stop):
#print "HANDLING BOX QUERY"
if self._labelControlUi.arrowToolButton.isChecked():
self.test(position5d_start, position5d_stop)
#elif self._labelControlUi.boxToolButton.isChecked():
# self.test2(position5d_start, position5d_stop)
def test2(self, position5d_start, position5d_stop):
print "test2"
roi = SubRegion(self.op.LabelInputs, position5d_start,
position5d_stop)
key = roi.toSlice()
#key = tuple(k for k in key if k != slice(0,0, None))
newKey = []
for k in key:
if k.stop < k.start:
k = slice(k.stop, k.start)
newKey.append(k)
newKey = tuple(newKey)
self.boxes[self.activeBox] = newKey
#self.op.BoxLabelImages[newKey] = self.activeBox + 2
#self.op.BoxLabelImages
labelShape = tuple([position5d_stop[i] + 1 - position5d_start[i] for i in range(5)])
labels = numpy.ones((labelShape), dtype = numpy.uint8) * (self.activeBox + 3)
self.boxlabelsrc.put(newKey, labels)
def test(self, position5d_start, position5d_stop):
print "test"
roi = SubRegion(self.op.Density, position5d_start,
position5d_stop)
key = roi.toSlice()
key = tuple(k for k in key if k != slice(0,0, None))
newKey = []
for k in key:
if k != slice(0,0,None):
if k.stop < k.start:
k = slice(k.stop, k.start)
newKey.append(k)
newKey = tuple(newKey)
try:
density = numpy.sum(self.op.Density[newKey].wait())
strdensity = "{0:.2f}".format(density)
self._labelControlUi.CountText.setText(strdensity)
except:
pass
def hideEvent(self, event):
#Ensure interactive is toggled of when leaving this GUI
self.toggleInteractive(False)
self.labelingDrawerUi.liveUpdateButton.setChecked(False)
LabelingGui.hideEvent(self, event)