def __init__(self):
SelectRuleset.__init__(self)
Players.load()
decorateWindow(self, i18n('Select four players'))
self.names = None
self.nameWidgets = []
for idx, wind in enumerate(Wind.all4):
cbName = QComboBox()
cbName.manualSelect = False
# increase width, we want to see the full window title
cbName.setMinimumWidth(350) # is this good for all platforms?
cbName.addItems(list(Players.humanNames.values()))
self.grid.addWidget(cbName, idx + 1, 1)
self.nameWidgets.append(cbName)
self.grid.addWidget(WindLabel(wind), idx + 1, 0)
cbName.currentIndexChanged.connect(self.slotValidate)
query = Query(
"select p0,p1,p2,p3 from game where seed is null and game.id = (select max(id) from game)"
)
if len(query.records):
with BlockSignals(self.nameWidgets):
for cbName, playerId in zip(self.nameWidgets,
query.records[0]):
try:
playerName = Players.humanNames[playerId]
playerIdx = cbName.findText(playerName)
if playerIdx >= 0:
cbName.setCurrentIndex(playerIdx)
except KeyError:
logError(
'database is inconsistent: player with id %d is in game but not in player'
% playerId)
self.slotValidate()
def setupUi(self):
"""create all Ui elements but do not fill them"""
self.buttonBox = KDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
# Ubuntu 11.10 unity is a bit strange - without this, it sets focus on
# the cancel button (which it shows on the left). I found no obvious
# way to use setDefault and setAutoDefault for fixing this.
self.buttonBox.button(QDialogButtonBox.Ok).setFocus(True)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
vbox = QVBoxLayout(self)
self.grid = QFormLayout()
self.cbServer = QComboBox()
self.cbServer.setEditable(True)
self.grid.addRow(i18n('Game server:'), self.cbServer)
self.cbUser = QComboBox()
self.cbUser.setEditable(True)
self.grid.addRow(i18n('Username:'******'Password:'******'kajongg', 'Ruleset:'), self.cbRuleset)
vbox.addLayout(self.grid)
vbox.addWidget(self.buttonBox)
pol = QSizePolicy()
pol.setHorizontalPolicy(QSizePolicy.Expanding)
self.cbUser.setSizePolicy(pol)
self.__port = None
class EWOListaSimple(ElementoWidgetOpciones, QGroupBox):
"""Es una lista de opciones en la que solo puede ser seleccionado uno de sus elementos.
Todos los elementos son mostrados simultaneamente"""
def __init__(self, parent, nombre, lista):
"""el ultimo parametro es la lista de posibles valores"""
ElementoWidgetOpciones.__init__(self)
QGroupBox.__init__(self, parent, "ListaSimple")
self.nombre = nombre
self.setTitle(nombre)
self.setColumnLayout(0, Qt.Vertical)
self.layout().setSpacing(6)
self.layout().setMargin(11)
llayout = QVBoxLayout(self.layout())
llayout.setAlignment(Qt.AlignTop)
layout12 = QHBoxLayout(None, 0, 6, "layout12")
label = QLabel(self, "label")
layout12.addWidget(label)
spacer7 = QSpacerItem(51, 31, QSizePolicy.Expanding, QSizePolicy.Minimum)
layout12.addItem(spacer7)
self.combo1 = QComboBox(0, self, "comboBox1")
layout12.addWidget(self.combo1)
spacer8 = QSpacerItem(131, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
layout12.addItem(spacer8)
llayout.addLayout(layout12)
for elemento in lista:
self.combo1.insertItem(elemento)
def opciones(self):
"""Devuelve las opciones seleccionadas"""
dic = {self.nombre:self.combo1.currentText().latin1()}
return dic
def setupUILastTileMeld(self, pGrid):
"""setup UI elements for last tile and last meld"""
self.lblLastTile = QLabel(i18n('&Last Tile:'))
self.cbLastTile = QComboBox()
self.cbLastTile.setMinimumContentsLength(1)
vpol = QSizePolicy()
vpol.setHorizontalPolicy(QSizePolicy.Fixed)
self.cbLastTile.setSizePolicy(vpol)
self.cbLastTile.setSizeAdjustPolicy(
QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastTile.setBuddy(self.cbLastTile)
self.lblLastMeld = QLabel(i18n('L&ast Meld:'))
self.prevLastTile = None
self.cbLastMeld = QComboBox()
self.cbLastMeld.setMinimumContentsLength(1)
self.cbLastMeld.setSizePolicy(vpol)
self.cbLastMeld.setSizeAdjustPolicy(
QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastMeld.setBuddy(self.cbLastMeld)
self.comboTilePairs = set()
pGrid.setRowStretch(6, 5)
pGrid.addWidget(self.lblLastTile, 7, 0, 1, 2)
pGrid.addWidget(self.cbLastTile, 7, 2, 1, 1)
pGrid.addWidget(self.lblLastMeld, 8, 0, 1, 2)
pGrid.addWidget(self.cbLastMeld, 8, 2, 1, 2)
def __init__(self, parent, *args):
QComboBox.__init__(self, False, parent, *args)
self.setAutoCompletion(True)
self.index_to_key = {}
self.key_to_index = {}
self.connect(self, SIGNAL("activated(int)"), self.slotItemSelected)
self.setSizePolicy(QSizePolicy(7, 0,
self.sizePolicy().hasHeightForWidth()))
def __init__(self):
SelectRuleset.__init__(self)
Players.load()
decorateWindow(self, m18n('Select four players'))
self.names = None
self.nameWidgets = []
for idx, wind in enumerate(Wind.all4):
cbName = QComboBox()
cbName.manualSelect = False
# increase width, we want to see the full window title
cbName.setMinimumWidth(350) # is this good for all platforms?
cbName.addItems(list(Players.humanNames.values()))
self.grid.addWidget(cbName, idx + 1, 1)
self.nameWidgets.append(cbName)
self.grid.addWidget(WindLabel(wind), idx + 1, 0)
cbName.currentIndexChanged.connect(self.slotValidate)
query = Query(
"select p0,p1,p2,p3 from game where seed is null and game.id = (select max(id) from game)")
if len(query.records):
with BlockSignals(self.nameWidgets):
for cbName, playerId in zip(self.nameWidgets, query.records[0]):
try:
playerName = Players.humanNames[playerId]
playerIdx = cbName.findText(playerName)
if playerIdx >= 0:
cbName.setCurrentIndex(playerIdx)
except KeyError:
logError(u'database is inconsistent: player with id %d is in game but not in player'
% playerId)
self.slotValidate()
def __init__(self, parent, tagTableName, tag = None, *args):
QComboBox.__init__(self, parent, *args)
self.setAutoCompletion(True)
self.setFont(guiConf.widgetfont)
self.index_to_key = {}
self.key_to_index = {}
self.strlist = []
self.mode = None
self.tagTableName = tagTableName
if tag != None:
self.slotRefresh(tag)
def __init__(self, parent, nombre, lista):
"""el ultimo parametro es la lista de posibles valores"""
ElementoWidgetOpciones.__init__(self)
QGroupBox.__init__(self, parent, "ListaSimple")
self.nombre = nombre
self.setTitle(nombre)
self.setColumnLayout(0, Qt.Vertical)
self.layout().setSpacing(6)
self.layout().setMargin(11)
llayout = QVBoxLayout(self.layout())
llayout.setAlignment(Qt.AlignTop)
layout12 = QHBoxLayout(None, 0, 6, "layout12")
label = QLabel(self, "label")
layout12.addWidget(label)
spacer7 = QSpacerItem(51, 31, QSizePolicy.Expanding, QSizePolicy.Minimum)
layout12.addItem(spacer7)
self.combo1 = QComboBox(0, self, "comboBox1")
layout12.addWidget(self.combo1)
spacer8 = QSpacerItem(131, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
layout12.addItem(spacer8)
llayout.addLayout(layout12)
for elemento in lista:
self.combo1.insertItem(elemento)
def __init__(self, phl_obj=None, parent=None):
super(IndexSimplerParamTab, self).__init__()
# self.param_widget_parent = parent.param_widget_parent
# indexing_method_check = QCheckBox("indexing.method")
hbox_method = QHBoxLayout()
label_method_62 = QLabel("Indexing Method")
hbox_method.addWidget(label_method_62)
box_method_62 = QComboBox()
box_method_62.tmp_lst = []
box_method_62.local_path = "indexing.method"
box_method_62.tmp_lst.append("fft3d")
box_method_62.tmp_lst.append("fft1d")
box_method_62.tmp_lst.append("real_space_grid_search")
box_method_62.tmp_lst.append("low_res_spot_match")
for lst_itm in box_method_62.tmp_lst:
box_method_62.addItem(lst_itm)
box_method_62.currentIndexChanged.connect(self.combobox_changed)
hbox_method.addWidget(box_method_62)
localLayout = QVBoxLayout()
localLayout.addLayout(hbox_method)
self.inner_reset_btn = ResetButton()
localLayout.addWidget(self.inner_reset_btn)
localLayout.addStretch()
self.setLayout(localLayout)
self.lst_var_widg = _get_all_direct_layout_widget_children(localLayout)
def setupUILastTileMeld(self, pGrid):
"""setup UI elements for last tile and last meld"""
self.lblLastTile = QLabel(m18n("&Last Tile:"))
self.cbLastTile = QComboBox()
self.cbLastTile.setMinimumContentsLength(1)
vpol = QSizePolicy()
vpol.setHorizontalPolicy(QSizePolicy.Fixed)
self.cbLastTile.setSizePolicy(vpol)
self.cbLastTile.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastTile.setBuddy(self.cbLastTile)
self.lblLastMeld = QLabel(m18n("L&ast Meld:"))
self.prevLastTile = None
self.cbLastMeld = QComboBox()
self.cbLastMeld.setMinimumContentsLength(1)
self.cbLastMeld.setSizePolicy(vpol)
self.cbLastMeld.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastMeld.setBuddy(self.cbLastMeld)
self.comboTilePairs = set()
pGrid.setRowStretch(6, 5)
pGrid.addWidget(self.lblLastTile, 7, 0, 1, 2)
pGrid.addWidget(self.cbLastTile, 7, 2, 1, 1)
pGrid.addWidget(self.lblLastMeld, 8, 0, 1, 2)
pGrid.addWidget(self.cbLastMeld, 8, 2, 1, 2)
def __init__(self, parent=None):
super(RefineBravaiSimplerParamTab, self).__init__()
localLayout = QVBoxLayout()
hbox_lay_outlier_algorithm = QHBoxLayout()
label_outlier_algorithm = QLabel("Outlier Rejection Algorithm")
hbox_lay_outlier_algorithm.addWidget(label_outlier_algorithm)
box_outlier_algorithm = QComboBox()
box_outlier_algorithm.local_path = "refinement.reflections.outlier.algorithm"
box_outlier_algorithm.tmp_lst = []
box_outlier_algorithm.tmp_lst.append("null")
box_outlier_algorithm.tmp_lst.append("auto")
box_outlier_algorithm.tmp_lst.append("mcd")
box_outlier_algorithm.tmp_lst.append("tukey")
box_outlier_algorithm.tmp_lst.append("sauter_poon")
for lst_itm in box_outlier_algorithm.tmp_lst:
box_outlier_algorithm.addItem(lst_itm)
box_outlier_algorithm.setCurrentIndex(1)
box_outlier_algorithm.currentIndexChanged.connect(
self.combobox_changed)
hbox_lay_outlier_algorithm.addWidget(box_outlier_algorithm)
localLayout.addLayout(hbox_lay_outlier_algorithm)
self.inner_reset_btn = ResetButton()
localLayout.addWidget(self.inner_reset_btn)
localLayout.addStretch()
self.setLayout(localLayout)
self.lst_var_widg = []
self.lst_var_widg.append(box_outlier_algorithm)
self.lst_var_widg.append(label_outlier_algorithm)
def __init__(self, items=None, parent=None):
QComboBox.__init__(self, parent)
self.items = items
class ScoringDialog(QWidget):
"""a dialog for entering the scores"""
# pylint: disable=too-many-instance-attributes
def __init__(self, scene):
QWidget.__init__(self)
self.scene = scene
decorateWindow(self, m18n("Scoring for this Hand"))
self.nameLabels = [None] * 4
self.spValues = [None] * 4
self.windLabels = [None] * 4
self.wonBoxes = [None] * 4
self.detailsLayout = [None] * 4
self.details = [None] * 4
self.__tilePixMaps = []
self.__meldPixMaps = []
grid = QGridLayout(self)
pGrid = QGridLayout()
grid.addLayout(pGrid, 0, 0, 2, 1)
pGrid.addWidget(QLabel(m18nc("kajongg", "Player")), 0, 0)
pGrid.addWidget(QLabel(m18nc("kajongg", "Wind")), 0, 1)
pGrid.addWidget(QLabel(m18nc("kajongg", "Score")), 0, 2)
pGrid.addWidget(QLabel(m18n("Winner")), 0, 3)
self.detailTabs = QTabWidget()
self.detailTabs.setDocumentMode(True)
pGrid.addWidget(self.detailTabs, 0, 4, 8, 1)
for idx in range(4):
self.setupUiForPlayer(pGrid, idx)
self.draw = QCheckBox(m18nc("kajongg", "Draw"))
self.draw.clicked.connect(self.wonChanged)
btnPenalties = QPushButton(m18n("&Penalties"))
btnPenalties.clicked.connect(self.penalty)
self.btnSave = QPushButton(m18n("&Save Hand"))
self.btnSave.clicked.connect(self.game.nextScoringHand)
self.btnSave.setEnabled(False)
self.setupUILastTileMeld(pGrid)
pGrid.setRowStretch(87, 10)
pGrid.addWidget(self.draw, 7, 3)
self.cbLastTile.currentIndexChanged.connect(self.slotLastTile)
self.cbLastMeld.currentIndexChanged.connect(self.slotInputChanged)
btnBox = QHBoxLayout()
btnBox.addWidget(btnPenalties)
btnBox.addWidget(self.btnSave)
pGrid.addLayout(btnBox, 8, 4)
StateSaver(self)
self.refresh()
@property
def game(self):
"""proxy"""
return self.scene.game
def setupUILastTileMeld(self, pGrid):
"""setup UI elements for last tile and last meld"""
self.lblLastTile = QLabel(m18n("&Last Tile:"))
self.cbLastTile = QComboBox()
self.cbLastTile.setMinimumContentsLength(1)
vpol = QSizePolicy()
vpol.setHorizontalPolicy(QSizePolicy.Fixed)
self.cbLastTile.setSizePolicy(vpol)
self.cbLastTile.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastTile.setBuddy(self.cbLastTile)
self.lblLastMeld = QLabel(m18n("L&ast Meld:"))
self.prevLastTile = None
self.cbLastMeld = QComboBox()
self.cbLastMeld.setMinimumContentsLength(1)
self.cbLastMeld.setSizePolicy(vpol)
self.cbLastMeld.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastMeld.setBuddy(self.cbLastMeld)
self.comboTilePairs = set()
pGrid.setRowStretch(6, 5)
pGrid.addWidget(self.lblLastTile, 7, 0, 1, 2)
pGrid.addWidget(self.cbLastTile, 7, 2, 1, 1)
pGrid.addWidget(self.lblLastMeld, 8, 0, 1, 2)
pGrid.addWidget(self.cbLastMeld, 8, 2, 1, 2)
def setupUiForPlayer(self, pGrid, idx):
"""setup UI elements for a player"""
self.spValues[idx] = QSpinBox()
self.nameLabels[idx] = QLabel()
self.nameLabels[idx].setBuddy(self.spValues[idx])
self.windLabels[idx] = WindLabel()
pGrid.addWidget(self.nameLabels[idx], idx + 2, 0)
pGrid.addWidget(self.windLabels[idx], idx + 2, 1)
pGrid.addWidget(self.spValues[idx], idx + 2, 2)
self.wonBoxes[idx] = QCheckBox("")
pGrid.addWidget(self.wonBoxes[idx], idx + 2, 3)
self.wonBoxes[idx].clicked.connect(self.wonChanged)
self.spValues[idx].valueChanged.connect(self.slotInputChanged)
detailTab = QWidget()
self.detailTabs.addTab(detailTab, "")
self.details[idx] = QWidget()
detailTabLayout = QVBoxLayout(detailTab)
detailTabLayout.addWidget(self.details[idx])
detailTabLayout.addStretch()
self.detailsLayout[idx] = QVBoxLayout(self.details[idx])
def refresh(self):
"""reload game"""
self.clear()
game = self.game
self.setVisible(game is not None and not game.finished())
if game:
for idx, player in enumerate(game.players):
for child in self.details[idx].children():
if isinstance(child, RuleBox):
child.hide()
self.detailsLayout[idx].removeWidget(child)
del child
if game:
self.spValues[idx].setRange(0, game.ruleset.limit or 99999)
self.nameLabels[idx].setText(player.localName)
self.windLabels[idx].wind = player.wind
self.windLabels[idx].roundsFinished = game.roundsFinished
self.detailTabs.setTabText(idx, player.localName)
player.manualRuleBoxes = [RuleBox(x) for x in game.ruleset.allRules if x.hasSelectable]
for ruleBox in player.manualRuleBoxes:
self.detailsLayout[idx].addWidget(ruleBox)
ruleBox.clicked.connect(self.slotInputChanged)
player.refreshManualRules()
def show(self):
"""only now compute content"""
if self.game and not self.game.finished():
self.slotInputChanged()
QWidget.show(self)
def penalty(self):
"""penalty button clicked"""
dlg = PenaltyDialog(self.game)
dlg.exec_()
def slotLastTile(self):
"""called when the last tile changes"""
newLastTile = self.computeLastTile()
if not newLastTile:
return
if self.prevLastTile and self.prevLastTile.isExposed != newLastTile.isExposed:
# state of last tile (concealed/exposed) changed:
# for all checked boxes check if they still are applicable
winner = self.game.winner
if winner:
for box in winner.manualRuleBoxes:
if box.isChecked():
box.setChecked(False)
if winner.hand.manualRuleMayApply(box.rule):
box.setChecked(True)
self.prevLastTile = newLastTile
self.fillLastMeldCombo()
self.slotInputChanged()
def computeLastTile(self):
"""returns the currently selected last tile"""
idx = self.cbLastTile.currentIndex()
if idx >= 0:
return variantValue(self.cbLastTile.itemData(idx))
def clickedPlayerIdx(self, checkbox):
"""the player whose box has been clicked"""
for idx in range(4):
if checkbox == self.wonBoxes[idx]:
return idx
assert False
def wonChanged(self):
"""if a new winner has been defined, uncheck any previous winner"""
newWinner = None
if self.sender() != self.draw:
clicked = self.clickedPlayerIdx(self.sender())
if self.wonBoxes[clicked].isChecked():
newWinner = self.game.players[clicked]
else:
newWinner = None
self.game.winner = newWinner
for idx in range(4):
if newWinner != self.game.players[idx]:
self.wonBoxes[idx].setChecked(False)
if newWinner:
self.draw.setChecked(False)
self.fillLastTileCombo()
self.slotInputChanged()
def updateManualRules(self):
"""enable/disable them"""
# if an exclusive rule has been activated, deactivate it for
# all other players
ruleBox = self.sender()
if isinstance(ruleBox, RuleBox) and ruleBox.isChecked() and ruleBox.rule.exclusive():
for idx, player in enumerate(self.game.players):
if ruleBox.parentWidget() != self.details[idx]:
for pBox in player.manualRuleBoxes:
if pBox.rule.name == ruleBox.rule.name:
pBox.setChecked(False)
try:
newState = bool(self.game.winner.handBoard.uiTiles)
except AttributeError:
newState = False
self.lblLastTile.setEnabled(newState)
self.cbLastTile.setEnabled(newState)
self.lblLastMeld.setEnabled(newState)
self.cbLastMeld.setEnabled(newState)
if self.game:
for player in self.game.players:
player.refreshManualRules(self.sender())
def clear(self):
"""prepare for next hand"""
if self.game:
for idx, player in enumerate(self.game.players):
self.spValues[idx].clear()
self.spValues[idx].setValue(0)
self.wonBoxes[idx].setChecked(False)
player.payment = 0
player.invalidateHand()
for box in self.wonBoxes:
box.setVisible(False)
self.draw.setChecked(False)
self.updateManualRules()
if self.game is None:
self.hide()
else:
for idx, player in enumerate(self.game.players):
self.windLabels[idx].setPixmap(WINDPIXMAPS[(player.wind, player.wind == self.game.roundWind)])
self.computeScores()
self.spValues[0].setFocus()
self.spValues[0].selectAll()
def computeScores(self):
"""if tiles have been selected, compute their value"""
# pylint: disable=too-many-branches
# too many branches
if not self.game:
return
if self.game.finished():
self.hide()
return
for nameLabel, wonBox, spValue, player in zip(self.nameLabels, self.wonBoxes, self.spValues, self.game.players):
with BlockSignals([spValue, wonBox]):
# we do not want that change to call computeScores again
if player.handBoard and player.handBoard.uiTiles:
spValue.setEnabled(False)
nameLabel.setBuddy(wonBox)
for _ in range(10):
prevTotal = player.handTotal
player.invalidateHand()
wonBox.setVisible(player.hand.won)
if not wonBox.isVisibleTo(self) and wonBox.isChecked():
wonBox.setChecked(False)
self.game.winner = None
elif prevTotal == player.handTotal:
break
player.refreshManualRules()
spValue.setValue(player.handTotal)
else:
if not spValue.isEnabled():
spValue.clear()
spValue.setValue(0)
spValue.setEnabled(True)
nameLabel.setBuddy(spValue)
wonBox.setVisible(player.handTotal >= self.game.ruleset.minMJTotal())
if not wonBox.isVisibleTo(self) and wonBox.isChecked():
wonBox.setChecked(False)
if not wonBox.isVisibleTo(self) and player is self.game.winner:
self.game.winner = None
if Internal.scene.explainView:
Internal.scene.explainView.refresh()
def __lastMeldContent(self):
"""prepare content for lastmeld combo"""
lastTiles = set()
winnerTiles = []
if self.game.winner and self.game.winner.handBoard:
winnerTiles = self.game.winner.handBoard.uiTiles
pairs = []
for meld in self.game.winner.hand.melds:
if len(meld) < 4:
pairs.extend(meld)
for tile in winnerTiles:
if tile.tile in pairs and not tile.isBonus:
lastTiles.add(tile.tile)
return lastTiles, winnerTiles
def __fillLastTileComboWith(self, lastTiles, winnerTiles):
"""fill last meld combo with prepared content"""
self.comboTilePairs = lastTiles
idx = self.cbLastTile.currentIndex()
if idx < 0:
idx = 0
indexedTile = variantValue(self.cbLastTile.itemData(idx))
restoredIdx = None
self.cbLastTile.clear()
if not winnerTiles:
return
pmSize = winnerTiles[0].board.tileset.faceSize
pmSize = QSize(pmSize.width() * 0.5, pmSize.height() * 0.5)
self.cbLastTile.setIconSize(pmSize)
QPixmapCache.clear()
self.__tilePixMaps = []
shownTiles = set()
for tile in winnerTiles:
if tile.tile in lastTiles and tile.tile not in shownTiles:
shownTiles.add(tile.tile)
self.cbLastTile.addItem(QIcon(tile.pixmapFromSvg(pmSize, withBorders=False)), "", toQVariant(tile.tile))
if indexedTile is tile.tile:
restoredIdx = self.cbLastTile.count() - 1
if not restoredIdx and indexedTile:
# try again, maybe the tile changed between concealed and exposed
indexedTile = indexedTile.exposed
for idx in range(self.cbLastTile.count()):
if indexedTile is variantValue(self.cbLastTile.itemData(idx)).exposed:
restoredIdx = idx
break
if not restoredIdx:
restoredIdx = 0
self.cbLastTile.setCurrentIndex(restoredIdx)
self.prevLastTile = self.computeLastTile()
def clearLastTileCombo(self):
"""as the name says"""
self.comboTilePairs = None
self.cbLastTile.clear()
def fillLastTileCombo(self):
"""fill the drop down list with all possible tiles.
If the drop down had content before try to preserve the
current index. Even if the tile changed state meanwhile."""
if self.game is None:
return
lastTiles, winnerTiles = self.__lastMeldContent()
if self.comboTilePairs == lastTiles:
return
with BlockSignals(self.cbLastTile):
# we only want to emit the changed signal once
self.__fillLastTileComboWith(lastTiles, winnerTiles)
self.cbLastTile.currentIndexChanged.emit(0)
def __fillLastMeldComboWith(self, winnerMelds, indexedMeld, lastTile):
"""fill last meld combo with prepared content"""
winner = self.game.winner
faceWidth = winner.handBoard.tileset.faceSize.width() * 0.5
faceHeight = winner.handBoard.tileset.faceSize.height() * 0.5
restoredIdx = None
for meld in winnerMelds:
pixMap = QPixmap(faceWidth * len(meld), faceHeight)
pixMap.fill(Qt.transparent)
self.__meldPixMaps.append(pixMap)
painter = QPainter(pixMap)
for element in meld:
painter.drawPixmap(
0,
0,
winner.handBoard.tilesByElement(element)[0].pixmapFromSvg(
QSize(faceWidth, faceHeight), withBorders=False
),
)
painter.translate(QPointF(faceWidth, 0.0))
self.cbLastMeld.addItem(QIcon(pixMap), "", toQVariant(str(meld)))
if indexedMeld == str(meld):
restoredIdx = self.cbLastMeld.count() - 1
if not restoredIdx and indexedMeld:
# try again, maybe the meld changed between concealed and exposed
indexedMeld = indexedMeld.lower()
for idx in range(self.cbLastMeld.count()):
meldContent = str(variantValue(self.cbLastMeld.itemData(idx)))
if indexedMeld == meldContent.lower():
restoredIdx = idx
if lastTile not in meldContent:
lastTile = lastTile.swapped
assert lastTile in meldContent
with BlockSignals(self.cbLastTile): # we want to continue right here
idx = self.cbLastTile.findData(toQVariant(lastTile))
self.cbLastTile.setCurrentIndex(idx)
break
if not restoredIdx:
restoredIdx = 0
self.cbLastMeld.setCurrentIndex(restoredIdx)
self.cbLastMeld.setIconSize(QSize(faceWidth * 3, faceHeight))
def fillLastMeldCombo(self):
"""fill the drop down list with all possible melds.
If the drop down had content before try to preserve the
current index. Even if the meld changed state meanwhile."""
with BlockSignals(self.cbLastMeld): # we only want to emit the changed signal once
showCombo = False
idx = self.cbLastMeld.currentIndex()
if idx < 0:
idx = 0
indexedMeld = str(variantValue(self.cbLastMeld.itemData(idx)))
self.cbLastMeld.clear()
self.__meldPixMaps = []
if not self.game.winner:
return
if self.cbLastTile.count() == 0:
return
lastTile = Internal.scene.computeLastTile()
winnerMelds = [m for m in self.game.winner.hand.melds if len(m) < 4 and lastTile in m]
assert len(winnerMelds), "lastTile %s missing in %s" % (lastTile, self.game.winner.hand.melds)
if len(winnerMelds) == 1:
self.cbLastMeld.addItem(QIcon(), "", toQVariant(str(winnerMelds[0])))
self.cbLastMeld.setCurrentIndex(0)
return
showCombo = True
self.__fillLastMeldComboWith(winnerMelds, indexedMeld, lastTile)
self.lblLastMeld.setVisible(showCombo)
self.cbLastMeld.setVisible(showCombo)
self.cbLastMeld.currentIndexChanged.emit(0)
def slotInputChanged(self):
"""some input fields changed: update"""
for player in self.game.players:
player.invalidateHand()
self.updateManualRules()
self.computeScores()
self.validate()
for player in self.game.players:
self.game.wall.decoratePlayer(player)
Internal.mainWindow.updateGUI()
def validate(self):
"""update the status of the OK button"""
game = self.game
if game:
valid = True
if game.winner and game.winner.handTotal < game.ruleset.minMJTotal():
valid = False
elif not game.winner and not self.draw.isChecked():
valid = False
self.btnSave.setEnabled(valid)
def showEvent(self, event):
"""Redefine el showEvent de qt"""
self.myUpdate()
QComboBox.showEvent(self, event)
def currentText(self):
return unicode(QComboBox.currentText(self) )
def __init__(self, parent=None):
super(IntegrateSimplerParamTab, self).__init__()
# self.param_widget_parent = parent.param_widget_parent
localLayout = QVBoxLayout()
PrFit_lay_out = QHBoxLayout()
label_PrFit = QLabel("Use Profile Fitting")
PrFit_lay_out.addWidget(label_PrFit)
PrFit_comb_bx = QComboBox()
PrFit_comb_bx.local_path = "integration.profile.fitting"
PrFit_comb_bx.tmp_lst = []
PrFit_comb_bx.tmp_lst.append("True")
PrFit_comb_bx.tmp_lst.append("False")
PrFit_comb_bx.tmp_lst.append("Auto")
for lst_itm in PrFit_comb_bx.tmp_lst:
PrFit_comb_bx.addItem(lst_itm)
PrFit_comb_bx.currentIndexChanged.connect(self.combobox_changed)
PrFit_lay_out.addWidget(PrFit_comb_bx)
localLayout.addLayout(PrFit_lay_out)
hbox_lay_algorithm_53 = QHBoxLayout()
label_algorithm_53 = QLabel("Background Algorithm")
hbox_lay_algorithm_53.addWidget(label_algorithm_53)
box_algorithm_53 = QComboBox()
box_algorithm_53.local_path = "integration.background.algorithm"
box_algorithm_53.tmp_lst = []
box_algorithm_53.tmp_lst.append("simple")
box_algorithm_53.tmp_lst.append("null")
box_algorithm_53.tmp_lst.append("median")
box_algorithm_53.tmp_lst.append("gmodel")
box_algorithm_53.tmp_lst.append("glm")
for lst_itm in box_algorithm_53.tmp_lst:
box_algorithm_53.addItem(lst_itm)
box_algorithm_53.setCurrentIndex(4)
box_algorithm_53.currentIndexChanged.connect(self.combobox_changed)
hbox_lay_algorithm_53.addWidget(box_algorithm_53)
localLayout.addLayout(hbox_lay_algorithm_53)
hbox_d_min = QHBoxLayout()
label_d_min = QLabel("d_min")
hbox_d_min.addWidget(label_d_min)
d_min_spn_bx = QDoubleSpinBox()
d_min_spn_bx.local_path = "prediction.d_min"
d_min_spn_bx.setSpecialValueText("None")
d_min_spn_bx.setValue(0.0)
hbox_d_min.addWidget(d_min_spn_bx)
d_min_spn_bx.valueChanged.connect(self.spnbox_changed)
localLayout.addLayout(hbox_d_min)
hbox_lay_nproc = QHBoxLayout()
label_nproc = QLabel("Number of Jobs")
# label_nproc.setFont( QFont("Monospace", 10))
hbox_lay_nproc.addWidget(label_nproc)
self.box_nproc = QSpinBox()
self.box_nproc.local_path = "integration.mp.nproc"
self.box_nproc.valueChanged.connect(self.spnbox_changed)
hbox_lay_nproc.addWidget(self.box_nproc)
localLayout.addLayout(hbox_lay_nproc)
self.inner_reset_btn = ResetButton()
localLayout.addWidget(self.inner_reset_btn)
localLayout.addStretch()
self.setLayout(localLayout)
self.box_nproc.tmp_lst = None
self.lst_var_widg = _get_all_direct_layout_widget_children(localLayout)
def clear(self):
QComboBox.clear(self)
self.index_to_key = {}
self.key_to_index = {}
self.strlist = []
def setupPanel(self, parentWidget):
logging.debug('ProstateTRUSNavUltrasound.setupPanel')
self.connectorNode = self.guideletParent.connectorNode
self.connectorNodeConnected = False
collapsibleButton = ctkCollapsibleButton()
collapsibleButton.setProperty('collapsedHeight', 20)
setButtonStyle(collapsibleButton, 2.0)
collapsibleButton.text = "Ultrasound"
parentWidget.addWidget(collapsibleButton)
ultrasoundLayout = QFormLayout(collapsibleButton)
ultrasoundLayout.setContentsMargins(12,4,4,4)
ultrasoundLayout.setSpacing(4)
self.connectDisconnectButton = QPushButton("Connect")
self.connectDisconnectButton.setToolTip("If clicked, connection OpenIGTLink")
hbox = QHBoxLayout()
hbox.addWidget(self.connectDisconnectButton)
ultrasoundLayout.addRow(hbox)
self.setupIcons()
self.captureIDSelector = QComboBox()
self.captureIDSelector.setToolTip("Pick capture device ID")
self.captureIDSelector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.volumeReconstructorIDSelector = QComboBox()
self.volumeReconstructorIDSelector.setToolTip( "Pick volume reconstructor device ID" )
self.volumeReconstructorIDSelector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.startStopRecordingButton = QPushButton(" Start Recording")
self.startStopRecordingButton.setCheckable(True)
self.startStopRecordingButton.setIcon(self.recordIcon)
self.startStopRecordingButton.setEnabled(False)
self.startStopRecordingButton.setToolTip("If clicked, start recording")
self.startStopRecordingButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
recordParametersControlsLayout = QGridLayout()
self.filenameLabel = self.createLabel("Filename:", visible=False)
recordParametersControlsLayout.addWidget(self.filenameLabel, 1, 0)
# Offline Reconstruction
self.offlineReconstructButton = QPushButton(" Offline Reconstruction")
self.offlineReconstructButton.setCheckable(True)
self.offlineReconstructButton.setIcon(self.recordIcon)
self.offlineReconstructButton.setEnabled(False)
self.offlineReconstructButton.setToolTip("If clicked, reconstruct recorded volume")
self.offlineReconstructButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.offlineVolumeToReconstructSelector = QComboBox()
self.offlineVolumeToReconstructSelector.setEditable(True)
self.offlineVolumeToReconstructSelector.setToolTip( "Pick/set volume to reconstruct" )
self.offlineVolumeToReconstructSelector.visible = False
hbox = QHBoxLayout()
hbox.addWidget(self.startStopRecordingButton)
hbox.addWidget(self.offlineReconstructButton)
ultrasoundLayout.addRow(hbox)
# Scout scan (record and low resolution reconstruction) and live reconstruction
# Scout scan part
self.startStopScoutScanButton = QPushButton(" Scout scan\n Start recording")
self.startStopScoutScanButton.setCheckable(True)
self.startStopScoutScanButton.setIcon(self.recordIcon)
self.startStopScoutScanButton.setToolTip("If clicked, start recording")
self.startStopScoutScanButton.setEnabled(False)
self.startStopScoutScanButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.startStopLiveReconstructionButton = QPushButton(" Start live reconstruction")
self.startStopLiveReconstructionButton.setCheckable(True)
self.startStopLiveReconstructionButton.setIcon(self.recordIcon)
self.startStopLiveReconstructionButton.setToolTip("If clicked, start live reconstruction")
self.startStopLiveReconstructionButton.setEnabled(False)
self.startStopLiveReconstructionButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.displayRoiButton = QToolButton()
self.displayRoiButton.setCheckable(True)
self.displayRoiButton.setIcon(self.visibleOffIcon)
self.displayRoiButton.setToolTip("If clicked, display ROI")
hbox = QHBoxLayout()
hbox.addWidget(self.startStopScoutScanButton)
hbox.addWidget(self.startStopLiveReconstructionButton)
# hbox.addWidget(self.displayRoiButton)
ultrasoundLayout.addRow(hbox)
self.snapshotTimer = QTimer()
self.snapshotTimer.setSingleShot(True)
self.onParameterSetSelected()
return collapsibleButton
def setupPanel(self, parentWidget):
logging.debug('ProstateTRUSNavUltrasound.setupPanel')
self.connectorNode = self.guideletParent.connectorNode
self.connectorNodeConnected = False
collapsibleButton = ctkCollapsibleButton()
collapsibleButton.setProperty('collapsedHeight', 20)
setButtonStyle(collapsibleButton, 2.0)
collapsibleButton.text = "Ultrasound"
parentWidget.addWidget(collapsibleButton)
ultrasoundLayout = QFormLayout(collapsibleButton)
ultrasoundLayout.setContentsMargins(12, 4, 4, 4)
ultrasoundLayout.setSpacing(4)
self.connectDisconnectButton = QPushButton("Connect")
self.connectDisconnectButton.setToolTip(
"If clicked, connection OpenIGTLink")
hbox = QHBoxLayout()
hbox.addWidget(self.connectDisconnectButton)
ultrasoundLayout.addRow(hbox)
self.setupIcons()
self.captureIDSelector = QComboBox()
self.captureIDSelector.setToolTip("Pick capture device ID")
self.captureIDSelector.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.volumeReconstructorIDSelector = QComboBox()
self.volumeReconstructorIDSelector.setToolTip(
"Pick volume reconstructor device ID")
self.volumeReconstructorIDSelector.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding)
self.startStopRecordingButton = QPushButton(" Start Recording")
self.startStopRecordingButton.setCheckable(True)
self.startStopRecordingButton.setIcon(self.recordIcon)
self.startStopRecordingButton.setEnabled(False)
self.startStopRecordingButton.setToolTip("If clicked, start recording")
self.startStopRecordingButton.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
recordParametersControlsLayout = QGridLayout()
self.filenameLabel = self.createLabel("Filename:", visible=False)
recordParametersControlsLayout.addWidget(self.filenameLabel, 1, 0)
# Offline Reconstruction
self.offlineReconstructButton = QPushButton(" Offline Reconstruction")
self.offlineReconstructButton.setCheckable(True)
self.offlineReconstructButton.setIcon(self.recordIcon)
self.offlineReconstructButton.setEnabled(False)
self.offlineReconstructButton.setToolTip(
"If clicked, reconstruct recorded volume")
self.offlineReconstructButton.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.offlineVolumeToReconstructSelector = QComboBox()
self.offlineVolumeToReconstructSelector.setEditable(True)
self.offlineVolumeToReconstructSelector.setToolTip(
"Pick/set volume to reconstruct")
self.offlineVolumeToReconstructSelector.visible = False
hbox = QHBoxLayout()
hbox.addWidget(self.startStopRecordingButton)
hbox.addWidget(self.offlineReconstructButton)
ultrasoundLayout.addRow(hbox)
# Scout scan (record and low resolution reconstruction) and live reconstruction
# Scout scan part
self.startStopScoutScanButton = QPushButton(
" Scout scan\n Start recording")
self.startStopScoutScanButton.setCheckable(True)
self.startStopScoutScanButton.setIcon(self.recordIcon)
self.startStopScoutScanButton.setToolTip("If clicked, start recording")
self.startStopScoutScanButton.setEnabled(False)
self.startStopScoutScanButton.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.startStopLiveReconstructionButton = QPushButton(
" Start live reconstruction")
self.startStopLiveReconstructionButton.setCheckable(True)
self.startStopLiveReconstructionButton.setIcon(self.recordIcon)
self.startStopLiveReconstructionButton.setToolTip(
"If clicked, start live reconstruction")
self.startStopLiveReconstructionButton.setEnabled(False)
self.startStopLiveReconstructionButton.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding)
self.displayRoiButton = QToolButton()
self.displayRoiButton.setCheckable(True)
self.displayRoiButton.setIcon(self.visibleOffIcon)
self.displayRoiButton.setToolTip("If clicked, display ROI")
hbox = QHBoxLayout()
hbox.addWidget(self.startStopScoutScanButton)
hbox.addWidget(self.startStopLiveReconstructionButton)
# hbox.addWidget(self.displayRoiButton)
ultrasoundLayout.addRow(hbox)
self.snapshotTimer = QTimer()
self.snapshotTimer.setSingleShot(True)
self.onParameterSetSelected()
return collapsibleButton
class ProstateTRUSNavUltrasound(UltraSound):
OFFLINE_VOLUME_FILENAME = "RecVol_Reference.mha"
SCOUT_VOLUME_FILENAME = "ScoutScan.mha"
LIVE_VOLUME_FILENAME = "LiveReconstructedVolume.mha"
RECORDING_FILENAME = "Recording.mha"
SCOUT_RECORDING_FILENAME = "ScoutScanRecording.mha"
LIVE_RECORDING_FILENAME = LIVE_VOLUME_FILENAME
SCOUT_VOLUME_NODE_NAME = "ScoutScan"
OFFLINE_VOLUME_NODE_NAME = "RecVol_Reference"
LIVE_VOLUME_NODE_NAME = "liveReconstruction"
APPLY_HOLE_FILLING_FOR_SNAPSHOT = False
SNAPSHOT_INTERVAL = 3
OUTPUT_VOLUME_SPACING = 3
LIVE_OUTPUT_VOLUME_SPACING = 1
@property
def roiNode(self):
return self._roiNode
@roiNode.setter
def roiNode(self, node):
self._roiNode = node
if node is not None:
self.startStopLiveReconstructionButton.setEnabled(True)
else:
self.startStopLiveReconstructionButton.setEnabled(False)
def __init__(self, guideletParent):
UltraSound.__init__(self, guideletParent)
self.parameterNode = guideletParent.parameterNode
self.parameterNodeObserver = None
self._roiNode = None
self.liveOutputSpacingValue = [
self.LIVE_OUTPUT_VOLUME_SPACING, self.LIVE_OUTPUT_VOLUME_SPACING,
self.LIVE_OUTPUT_VOLUME_SPACING
]
self.outputSpacing = [
self.OUTPUT_VOLUME_SPACING, self.OUTPUT_VOLUME_SPACING,
self.OUTPUT_VOLUME_SPACING
]
self.roiOrigin = None
self.roiExtent = None
self.defaultParameterNode = None
self.logic = ProstateTRUSNavUltrasoundLogic()
def setupPanel(self, parentWidget):
logging.debug('ProstateTRUSNavUltrasound.setupPanel')
self.connectorNode = self.guideletParent.connectorNode
self.connectorNodeConnected = False
collapsibleButton = ctkCollapsibleButton()
collapsibleButton.setProperty('collapsedHeight', 20)
setButtonStyle(collapsibleButton, 2.0)
collapsibleButton.text = "Ultrasound"
parentWidget.addWidget(collapsibleButton)
ultrasoundLayout = QFormLayout(collapsibleButton)
ultrasoundLayout.setContentsMargins(12, 4, 4, 4)
ultrasoundLayout.setSpacing(4)
self.connectDisconnectButton = QPushButton("Connect")
self.connectDisconnectButton.setToolTip(
"If clicked, connection OpenIGTLink")
hbox = QHBoxLayout()
hbox.addWidget(self.connectDisconnectButton)
ultrasoundLayout.addRow(hbox)
self.setupIcons()
self.captureIDSelector = QComboBox()
self.captureIDSelector.setToolTip("Pick capture device ID")
self.captureIDSelector.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.volumeReconstructorIDSelector = QComboBox()
self.volumeReconstructorIDSelector.setToolTip(
"Pick volume reconstructor device ID")
self.volumeReconstructorIDSelector.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding)
self.startStopRecordingButton = QPushButton(" Start Recording")
self.startStopRecordingButton.setCheckable(True)
self.startStopRecordingButton.setIcon(self.recordIcon)
self.startStopRecordingButton.setEnabled(False)
self.startStopRecordingButton.setToolTip("If clicked, start recording")
self.startStopRecordingButton.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
recordParametersControlsLayout = QGridLayout()
self.filenameLabel = self.createLabel("Filename:", visible=False)
recordParametersControlsLayout.addWidget(self.filenameLabel, 1, 0)
# Offline Reconstruction
self.offlineReconstructButton = QPushButton(" Offline Reconstruction")
self.offlineReconstructButton.setCheckable(True)
self.offlineReconstructButton.setIcon(self.recordIcon)
self.offlineReconstructButton.setEnabled(False)
self.offlineReconstructButton.setToolTip(
"If clicked, reconstruct recorded volume")
self.offlineReconstructButton.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.offlineVolumeToReconstructSelector = QComboBox()
self.offlineVolumeToReconstructSelector.setEditable(True)
self.offlineVolumeToReconstructSelector.setToolTip(
"Pick/set volume to reconstruct")
self.offlineVolumeToReconstructSelector.visible = False
hbox = QHBoxLayout()
hbox.addWidget(self.startStopRecordingButton)
hbox.addWidget(self.offlineReconstructButton)
ultrasoundLayout.addRow(hbox)
# Scout scan (record and low resolution reconstruction) and live reconstruction
# Scout scan part
self.startStopScoutScanButton = QPushButton(
" Scout scan\n Start recording")
self.startStopScoutScanButton.setCheckable(True)
self.startStopScoutScanButton.setIcon(self.recordIcon)
self.startStopScoutScanButton.setToolTip("If clicked, start recording")
self.startStopScoutScanButton.setEnabled(False)
self.startStopScoutScanButton.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.startStopLiveReconstructionButton = QPushButton(
" Start live reconstruction")
self.startStopLiveReconstructionButton.setCheckable(True)
self.startStopLiveReconstructionButton.setIcon(self.recordIcon)
self.startStopLiveReconstructionButton.setToolTip(
"If clicked, start live reconstruction")
self.startStopLiveReconstructionButton.setEnabled(False)
self.startStopLiveReconstructionButton.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding)
self.displayRoiButton = QToolButton()
self.displayRoiButton.setCheckable(True)
self.displayRoiButton.setIcon(self.visibleOffIcon)
self.displayRoiButton.setToolTip("If clicked, display ROI")
hbox = QHBoxLayout()
hbox.addWidget(self.startStopScoutScanButton)
hbox.addWidget(self.startStopLiveReconstructionButton)
# hbox.addWidget(self.displayRoiButton)
ultrasoundLayout.addRow(hbox)
self.snapshotTimer = QTimer()
self.snapshotTimer.setSingleShot(True)
self.onParameterSetSelected()
return collapsibleButton
def setupResliceDriver(self):
layoutManager = slicer.app.layoutManager()
# Show ultrasound in red view.
redSlice = layoutManager.sliceWidget('Red')
redSliceLogic = redSlice.sliceLogic()
redSliceLogic.GetSliceCompositeNode().SetBackgroundVolumeID(
self.liveUltrasoundNode_Reference.GetID())
resliceLogic = slicer.modules.volumereslicedriver.logic()
if resliceLogic:
redNode = slicer.util.getNode('vtkMRMLSliceNodeRed')
redNode.SetSliceResolutionMode(
slicer.vtkMRMLSliceNode.SliceResolutionMatchVolumes)
resliceLogic.SetDriverForSlice(
self.liveUltrasoundNode_Reference.GetID(), redNode)
resliceLogic.SetModeForSlice(
6, redNode) # Transverse mode, default for PLUS ultrasound.
else:
logging.warning('Logic not found for Volume Reslice Driver')
def createCollapsibleButton(self, text, collapsed=False):
collapsibleButton = ctkCollapsibleButton()
collapsibleButton.text = text
collapsibleButton.collapsed = collapsed
return collapsibleButton
def createLabel(self, text, visible=True):
label = QLabel()
label.setText(text)
label.visible = visible
return label
def setupConnections(self):
self.startStopRecordingButton.connect(
'clicked(bool)', self.onStartStopRecordingButtonClicked)
self.offlineReconstructButton.connect('clicked(bool)',
self.onReconstVolume)
self.startStopScoutScanButton.connect(
'clicked(bool)', self.onStartStopScoutScanButtonClicked)
self.startStopLiveReconstructionButton.connect(
'clicked(bool)', self.onStartStopLiveReconstructionButtonClicked)
self.displayRoiButton.connect('clicked(bool)',
self.onDisplayRoiButtonClicked)
self.captureIDSelector.connect('currentIndexChanged(QString)',
self.updateParameterNodeFromGui)
self.volumeReconstructorIDSelector.connect(
'currentIndexChanged(QString)', self.updateParameterNodeFromGui)
self.offlineVolumeToReconstructSelector.connect(
'currentIndexChanged(int)', self.updateParameterNodeFromGui)
self.displayRoiButton.connect('clicked(bool)',
self.updateParameterNodeFromGui)
self.snapshotTimer.timeout.connect(
self.onRequestVolumeReconstructionSnapshot)
self.connectDisconnectButton.connect(
'clicked(bool)', self.onConnectDisconnectButtonClicked)
def disconnect(self):
self.startStopRecordingButton.disconnect(
'clicked(bool)', self.onStartStopRecordingButtonClicked)
self.offlineReconstructButton.disconnect('clicked(bool)',
self.onReconstVolume)
self.startStopScoutScanButton.disconnect(
'clicked(bool)', self.onStartStopScoutScanButtonClicked)
self.startStopLiveReconstructionButton.disconnect(
'clicked(bool)', self.onStartStopLiveReconstructionButtonClicked)
self.displayRoiButton.disconnect('clicked(bool)',
self.onDisplayRoiButtonClicked)
self.captureIDSelector.disconnect('currentIndexChanged(QString)',
self.updateParameterNodeFromGui)
self.volumeReconstructorIDSelector.disconnect(
'currentIndexChanged(QString)', self.updateParameterNodeFromGui)
self.offlineVolumeToReconstructSelector.disconnect(
'currentIndexChanged(int)', self.updateParameterNodeFromGui)
self.displayRoiButton.disconnect('clicked(bool)',
self.updateParameterNodeFromGui)
self.snapshotTimer.timeout.disconnect(
self.onRequestVolumeReconstructionSnapshot)
self.connectDisconnectButton.disconnect(
'clicked(bool)', self.onConnectDisconnectButtonClicked)
def setupIcons(self):
self.plusRemoteModuleDirectoryPath = slicer.modules.plusremote.path.replace(
"PlusRemote.py", "")
self.recordIcon = QIcon(self.plusRemoteModuleDirectoryPath +
'/Resources/Icons/icon_Record.png')
self.stopIcon = QIcon(self.plusRemoteModuleDirectoryPath +
'/Resources/Icons/icon_Stop.png')
self.waitIcon = QIcon(self.plusRemoteModuleDirectoryPath +
'/Resources/Icons/icon_Wait.png')
self.visibleOffIcon = QIcon(":Icons\VisibleOff.png")
self.visibleOnIcon = QIcon(":Icons\VisibleOn.png")
def onParameterSetSelected(self):
# Set up default values for new nodes
if self.parameterNode:
self.plusRemoteLogic.setDefaultParameters(self.parameterNode)
self.updateGuiFromParameterNode()
def updateGuiFromParameterNode(self):
self.parameterVolumeList = {
'OfflineVolumeToReconstruct':
self.offlineVolumeToReconstructSelector
}
for parameter in self.parameterVolumeList:
if self.parameterNode.GetParameter(parameter):
self.parameterVolumeList[parameter].blockSignals(True)
self.parameterVolumeList[parameter].blockSignals(False)
if self.parameterNode.GetParameter('CaptureID'):
self.captureIDSelector.blockSignals(True)
for i in range(0, self.captureIDSelector.count):
if self.parameterNode.GetParameter(
'CaptureID') == self.captureIDSelector.itemText(i):
self.captureIDSelector.setCurrentIndex(
int(self.parameterNode.GetParameter('CaptureIdIndex')))
self.captureIDSelector.blockSignals(False)
if self.parameterNode.GetParameter('VolumeReconstructor'):
self.volumeReconstructorIDSelector.blockSignals(True)
for i in range(0, self.volumeReconstructorIDSelector.count):
if self.parameterNode.GetParameter(
'VolumeReconstructor'
) == self.volumeReconstructorIDSelector.itemText(i):
self.volumeReconstructorIDSelector.setCurrentIndex(
int(
self.parameterNode.GetParameter(
'VolumeReconstructorIndex')))
self.volumeReconstructorIDSelector.blockSignals(False)
self.roiNode = self.parameterNode.GetNthNodeReference('ROI', 0)
def updateParameterNodeFromGui(self):
#Update parameter node value to save when user change value in the interface
if not self.parameterNode:
return
self.parametersList = {
'CaptureID':
self.captureIDSelector.currentText,
'CaptureIdIndex':
self.captureIDSelector.currentIndex,
'VolumeReconstructor':
self.volumeReconstructorIDSelector.currentText,
'VolumeReconstructorIndex':
self.volumeReconstructorIDSelector.currentIndex,
'OfflineVolumeToReconstruct':
self.offlineVolumeToReconstructSelector.currentIndex
}
for parameter in self.parametersList:
self.parameterNode.SetParameter(
parameter, str(self.parametersList[parameter]))
if self.roiNode:
roiNodeID = self.roiNode.GetID()
self.parameterNode.SetNthNodeReferenceID('ROI', 0, roiNodeID)
#
# Connector observation and actions
#
def onConnectorNodeConnected(self):
logging.debug("ProstateTrusUltrasound:onConnectorNodeConnected")
self.connectorNodeConnected = True
self.captureIDSelector.setDisabled(False)
self.volumeReconstructorIDSelector.setDisabled(False)
self.plusRemoteLogic.getCaptureDeviceIds(
self.connectorNode.GetID(),
self.onGetCaptureDeviceCommandResponseReceived)
self.plusRemoteLogic.getVolumeReconstructorDeviceIds(
self.connectorNode.GetID(),
self.onGetVolumeReconstructorDeviceCommandResponseReceived)
self.connectDisconnectButton.setText("Disconnect")
def onConnectorNodeDisconnected(self):
logging.debug("ProstateTrusUltrasound:onConnectorNodeDisconnected")
self.connectorNodeConnected = False
self.startStopRecordingButton.setEnabled(False)
self.startStopScoutScanButton.setEnabled(False)
self.startStopLiveReconstructionButton.setEnabled(False)
self.offlineReconstructButton.setEnabled(False)
self.captureIDSelector.setDisabled(True)
self.volumeReconstructorIDSelector.setDisabled(True)
self.connectDisconnectButton.setText("Connect")
def getLiveVolumeRecNode(self):
liveVolumeRecNode = slicer.util.getNode(self.LIVE_VOLUME_NODE_NAME)
return liveVolumeRecNode
def getOfflineVolumeRecNode(self):
offlineVolumeRecNode = slicer.util.getNode(
self.OFFLINE_VOLUME_NODE_NAME)
return offlineVolumeRecNode
def getScoutVolumeNode(self):
scoutScanVolumeNode = slicer.util.getNode(self.SCOUT_VOLUME_NODE_NAME)
return scoutScanVolumeNode
def onConnectDisconnectButtonClicked(self):
if self.connectorNode.GetState(
) == slicer.vtkMRMLIGTLConnectorNode.STATE_CONNECTED:
self.connectorNode.Stop()
else:
self.connectorNode.Start()
def onStartStopRecordingButtonClicked(self):
if self.startStopRecordingButton.isChecked():
self.startStopRecordingButton.setText(" Stop Recording")
self.startStopRecordingButton.setIcon(self.stopIcon)
self.startStopRecordingButton.setToolTip(
"If clicked, stop recording")
self.onStartRecording(self.generateRecordingOutputFilename())
else:
self.startStopRecordingButton.setText(" Start Recording")
self.startStopRecordingButton.setIcon(self.recordIcon)
self.startStopRecordingButton.setToolTip(
"If clicked, start recording")
self.onStopRecording(self.onVolumeRecorded)
def onStartStopScoutScanButtonClicked(self):
if self.startStopScoutScanButton.isChecked():
self.startStopScoutScanButton.setText(
" Scout Scan\n Stop Recording and Reconstruct Recorded Volume"
)
self.startStopScoutScanButton.setIcon(self.stopIcon)
self.startStopScoutScanButton.setToolTip(
"If clicked, stop recording and reconstruct recorded volume")
self.onStartRecording(self.generateScoutRecordingOutputFilename())
else:
self.onStopRecording(self.onScoutVolumeRecorded)
def onStartStopLiveReconstructionButtonClicked(self):
if self.startStopLiveReconstructionButton.isChecked():
if self.roiNode:
self.roiOrigin, self.roiExtent = self.logic.updateVolumeOriginAndExtentFromROI(
self.LIVE_OUTPUT_VOLUME_SPACING, self.roiNode)
self.startStopLiveReconstructionButton.setText(
" Stop Live Reconstruction")
self.startStopLiveReconstructionButton.setIcon(self.stopIcon)
self.startStopLiveReconstructionButton.setToolTip(
"If clicked, stop live reconstruction")
self.onStartRecording(self.getLiveRecordingOutputFilename())
self.onStartReconstruction()
else:
self.startStopLiveReconstructionButton.setText(
" Start Live Reconstruction")
self.startStopLiveReconstructionButton.setIcon(self.recordIcon)
self.startStopLiveReconstructionButton.setToolTip(
"If clicked, start live reconstruction")
self.onStopRecording(self.printCommandResponse)
self.onStopReconstruction()
def onDisplayRoiButtonClicked(self):
if self.displayRoiButton.isChecked():
self.displayRoiButton.setIcon(self.visibleOnIcon)
self.displayRoiButton.setToolTip("If clicked, hide ROI")
if self.roiNode:
self.roiNode.SetDisplayVisibility(1)
else:
self.displayRoiButton.setIcon(self.visibleOffIcon)
self.displayRoiButton.setToolTip("If clicked, display ROI")
if self.roiNode:
self.roiNode.SetDisplayVisibility(0)
def generateRecordingOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(
self.RECORDING_FILENAME)
def generateScoutRecordingOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(
self.SCOUT_RECORDING_FILENAME)
def getLiveRecordingOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(
self.LIVE_RECORDING_FILENAME)
def getLiveReconstructionOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(
self.LIVE_VOLUME_FILENAME)
def onStartRecording(self, filename):
self.plusRemoteLogic.startRecording(self.connectorNode.GetID(),
self.captureIDSelector.currentText,
filename,
self.printCommandResponse)
def onStopRecording(self, callback):
self.plusRemoteLogic.stopRecording(self.connectorNode.GetID(),
self.captureIDSelector.currentText,
callback)
def onStartReconstruction(self):
if self.roiNode:
self.roiOrigin, self.roiExtent = self.logic.updateVolumeOriginAndExtentFromROI(
self.LIVE_OUTPUT_VOLUME_SPACING, self.roiNode)
self.plusRemoteLogic.startVolumeReconstuction(
self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.liveOutputSpacingValue, self.roiOrigin, self.roiExtent,
self.printCommandResponse,
self.getLiveReconstructionOutputFilename(),
self.LIVE_VOLUME_NODE_NAME)
# Set up timer for requesting snapshot
self.snapshotTimer.start(self.SNAPSHOT_INTERVAL * 1000)
def onStopReconstruction(self):
self.snapshotTimer.stop()
self.plusRemoteLogic.stopVolumeReconstruction(
self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.onVolumeLiveReconstructed,
self.getLiveReconstructionOutputFilename(),
self.LIVE_VOLUME_NODE_NAME)
def onReconstVolume(self):
self.offlineReconstructButton.setIcon(self.waitIcon)
self.offlineReconstructButton.setText(
" Offline Reconstruction in progress ...")
self.offlineReconstructButton.setEnabled(False)
self.plusRemoteLogic.reconstructRecorded(
self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.offlineVolumeToReconstructSelector.currentText,
self.outputSpacing, self.onVolumeReconstructed,
self.OFFLINE_VOLUME_FILENAME, self.OFFLINE_VOLUME_NODE_NAME)
def onScoutScanReconstVolume(self):
self.startStopScoutScanButton.setIcon(self.waitIcon)
self.startStopScoutScanButton.setText(
" Scout Scan\n Reconstruction in progress ...")
self.startStopScoutScanButton.setEnabled(False)
self.plusRemoteLogic.reconstructRecorded(
self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.lastScoutRecordingOutputFilename, self.outputSpacing,
self.onScoutVolumeReconstructed, self.SCOUT_VOLUME_FILENAME,
self.SCOUT_VOLUME_NODE_NAME)
def onRequestVolumeReconstructionSnapshot(self, stopFlag=""):
self.plusRemoteLogic.getVolumeReconstructionSnapshot(
self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.LIVE_VOLUME_FILENAME, self.LIVE_VOLUME_NODE_NAME,
self.APPLY_HOLE_FILLING_FOR_SNAPSHOT, self.onSnapshotAcquired)
def executeCommandDelayed(self, method, delay=100):
# Order of OpenIGTLink message receiving and processing is not guaranteed to be the same
# therefore we wait a bit to make sure the image message is processed as well
QTimer.singleShot(delay, method)
def printCommandResponse(self, command, q):
statusText = "Command {0} [{1}]: {2}\n".format(
command.GetCommandName(), command.GetID(),
command.StatusToString(command.GetStatus()))
if command.GetResponseMessage():
statusText = statusText + command.GetResponseMessage()
elif command.GetResponseText():
statusText = statusText + command.GetResponseText()
logging.debug(statusText)
def onGetCaptureDeviceCommandResponseReceived(self, command, q):
self.printCommandResponse(command, q)
if command.GetStatus() != command.CommandSuccess:
return
captureDeviceIdsListString = command.GetResponseMessage()
if captureDeviceIdsListString:
captureDevicesIdsList = captureDeviceIdsListString.split(",")
else:
captureDevicesIdsList = []
for i in range(0, len(captureDevicesIdsList)):
if self.captureIDSelector.findText(captureDevicesIdsList[i]) == -1:
self.captureIDSelector.addItem(captureDevicesIdsList[i])
def onGetVolumeReconstructorDeviceCommandResponseReceived(
self, command, q):
self.printCommandResponse(command, q)
if command.GetStatus() != command.CommandSuccess:
return
volumeReconstructorDeviceIdsListString = command.GetResponseMessage()
if volumeReconstructorDeviceIdsListString:
volumeReconstructorDeviceIdsList = volumeReconstructorDeviceIdsListString.split(
",")
else:
volumeReconstructorDeviceIdsList = []
self.volumeReconstructorIDSelector.clear()
self.volumeReconstructorIDSelector.addItems(
volumeReconstructorDeviceIdsList)
self.startStopRecordingButton.setEnabled(True)
self.offlineReconstructButton.setEnabled(True)
self.startStopScoutScanButton.setEnabled(True)
if self.roiNode:
self.startStopLiveReconstructionButton.setEnabled(True)
def onVolumeRecorded(self, command, q):
self.printCommandResponse(command, q)
self.offlineReconstructButton.setEnabled(True)
volumeToReconstructFileName = os.path.basename(
command.GetResponseMessage())
self.offlineVolumeToReconstructSelector.insertItem(
0, volumeToReconstructFileName)
self.offlineVolumeToReconstructSelector.setCurrentIndex(0)
def onScoutVolumeRecorded(self, command, q):
self.printCommandResponse(command, q)
self.offlineReconstructButton.setEnabled(True)
if command.GetStatus() == command.CommandExpired:
logging.fatal(
"Scout Volume Recording: Timeout while waiting for volume reconstruction result"
)
return
if command.GetStatus() == command.CommandSuccess:
self.lastScoutRecordingOutputFilename = os.path.basename(
command.GetResponseMessage())
self.onScoutScanReconstVolume()
def onVolumeReconstructed(self, command, q):
self.printCommandResponse(command, q)
self.offlineReconstructButton.setIcon(self.recordIcon)
self.offlineReconstructButton.setText("Offline Reconstruction")
self.offlineReconstructButton.setEnabled(True)
self.offlineReconstructButton.setChecked(False)
if command.GetStatus() == command.CommandExpired:
# volume reconstruction command timed out
logging.fatal(
"Volume Reconstruction: Timeout while waiting for volume reconstruction result"
)
return
if command.GetStatus() != command.CommandSuccess:
logging.debug("Volume Reconstruction: " +
command.GetResponseMessage())
return
self.executeCommandDelayed(self.onVolumeReconstructedFinalize)
def onVolumeReconstructedFinalize(self):
applicationLogic = slicer.app.applicationLogic()
applicationLogic.FitSliceToAll()
self.guideletParent.showVolumeRendering(self.getOfflineVolumeRecNode())
def onScoutVolumeReconstructed(self, command, q):
self.printCommandResponse(command, q)
if command.GetStatus() == command.CommandExpired:
logging.fatal(
"Scout Volume Reconstruction: Timeout while waiting for scout volume reconstruction result"
)
return
self.startStopScoutScanButton.setIcon(self.recordIcon)
self.startStopScoutScanButton.setText(
" Scout Scan\n Start Recording")
self.startStopScoutScanButton.setEnabled(True)
if command.GetStatus() != command.CommandSuccess:
logging.debug("Scout Volume Reconstruction: " +
command.GetResponseMessage())
return
self.executeCommandDelayed(self.onScoutVolumeReconstructedFinalize)
def onScoutVolumeReconstructedFinalize(self):
# Create and initialize ROI after scout scan because low resolution scout scan is used to set
# a smaller ROI for the live high resolution reconstruction
self.roiNode = self.logic.onRoiInitialization(
self.SCOUT_VOLUME_NODE_NAME, self.roiNode)
self.roiOrigin, self.roiExtent = self.logic.updateVolumeOriginAndExtentFromROI(
self.LIVE_OUTPUT_VOLUME_SPACING, self.roiNode)
scoutScanVolumeNode = self.getScoutVolumeNode()
applicationLogic = slicer.app.applicationLogic()
applicationLogic.FitSliceToAll()
self.guideletParent.showVolumeRendering(scoutScanVolumeNode)
def onSnapshotAcquired(self, command, q):
self.printCommandResponse(command, q)
if not self.startStopLiveReconstructionButton.isChecked():
# live volume reconstruction is not active
return
self.executeCommandDelayed(self.onSnapshotAcquiredFinalize)
def onSnapshotAcquiredFinalize(self):
self.guideletParent.showVolumeRendering(self.getLiveVolumeRecNode())
self.snapshotTimer.start(self.SNAPSHOT_INTERVAL * 1000)
def onVolumeLiveReconstructed(self, command, q):
self.printCommandResponse(command, q)
if command.GetStatus() == command.CommandExpired:
logging.fatal(
"LIVE Volume Reconstruction: Failed to stop volume reconstruction"
)
return
if command.GetStatus() != command.CommandSuccess:
logging.debug("LIVE Volume Reconstruction " +
command.GetResponseMessage())
return
self.executeCommandDelayed(self.getLiveVolumeRecNode)
def onVolumeLiveReconstructedFinalize(self):
self.guideletParent.showVolumeRendering(self.getLiveVolumeRecNode())
def phil_list2gui(self, lst_phil_obj):
sys_font = QFont()
sys_font_point_size = sys_font.pointSize()
inde_step = 4
self.lst_label_widg = []
self.lst_var_widg = []
non_added_lst = []
for nm, obj in enumerate(lst_phil_obj):
if str(type(obj))[-11:-2] == "ScopeData":
tmp_str = " " * int(obj.indent * inde_step) + str(obj.name)
# print tmp_str
tmp_widg = QLabel(tmp_str)
tmp_widg.setAutoFillBackground(True)
# tmp_widg.setPalette(self.plt_scp)
tmp_widg.setFont(
QFont("Monospace", sys_font_point_size, QFont.Bold))
tmp_widg.style_orign = "color: rgba(85, 85, 85, 255)"
tmp_widg.setStyleSheet(tmp_widg.style_orign)
self.bg_box.addWidget(tmp_widg)
tmp_widg.test_flag = "Yes"
self.lst_label_widg.append(tmp_widg)
else:
tmp_h_box = QHBoxLayout()
indent = str(obj.full_path()).count(".")
tmp_str = " " * indent * inde_step + str(obj.name)
tmp_label = QLabel(tmp_str)
tmp_label.setAutoFillBackground(True)
# tmp_label.setPalette(self.plt_obj)
tmp_label.style_orign = "color: rgba(0, 0, 0, 255)"
tmp_label.setStyleSheet(tmp_label.style_orign)
tmp_label.setFont(QFont("Monospace", sys_font_point_size))
tmp_h_box.addWidget(tmp_label)
self.lst_label_widg.append(tmp_label)
if (obj.type.phil_type == "bool"
or obj.type.phil_type == "choice"):
if obj.type.phil_type == "bool":
tmp_widg = QComboBox()
tmp_widg.tmp_lst = []
tmp_widg.tmp_lst.append("True")
tmp_widg.tmp_lst.append("False")
tmp_widg.tmp_lst.append("Auto")
for lst_itm in tmp_widg.tmp_lst:
tmp_widg.addItem(lst_itm)
if str(obj.extract()) == "True":
tmp_widg.setCurrentIndex(0)
tmp_str += " True"
elif str(obj.extract()) == "False":
tmp_widg.setCurrentIndex(1)
tmp_str += " False"
elif str(obj.extract()) == "Auto":
tmp_widg.setCurrentIndex(2)
tmp_str += " Auto"
else:
tmp_str = None
#print("tmp_widg.tmp_lst =", tmp_widg.tmp_lst)
#print("tmp_str =", tmp_str)
tmp_widg.currentIndexChanged.connect(
self.combobox_changed)
elif obj.type.phil_type == "choice":
# remember to ask david about the issue here
# tmp_widg = QComboBox()
# tmp_widg.tmp_lst=[]
# pos = 0
# found_choise = False
# for num, opt in enumerate(obj.words):
# opt = str(opt)
# if(opt[0] == "*"):
# found_choise = True
# opt = opt[1:]
# pos = num
# tmp_str += " " + opt
# tmp_widg.tmp_lst.append(opt)
# for lst_itm in tmp_widg.tmp_lst:
# tmp_widg.addItem(lst_itm)
# tmp_widg.setCurrentIndex(pos)
# tmp_widg.currentIndexChanged.connect(self.combobox_changed)
# if(found_choise == False):
# tmp_str = None
# non_added_lst.append(str(obj.full_path()))
# begins pathed version
tmp_widg = QComboBox()
tmp_widg.tmp_lst = []
pos = 0
found_choise = False
for num, opt in enumerate(obj.words):
opt = str(opt)
if opt[0] == "*":
found_choise = True
opt = opt[1:]
pos = num
tmp_str += " " + opt
tmp_widg.tmp_lst.append(opt)
if not found_choise:
tmp_str += " " + str(
obj.extract())
for lst_itm in tmp_widg.tmp_lst:
tmp_widg.addItem(lst_itm)
tmp_widg.setCurrentIndex(pos)
tmp_widg.currentIndexChanged.connect(
self.combobox_changed)
# ends pathed version
else:
tmp_widg = QLineEdit()
tmp_widg.setText("")
tmp_widg.str_defl = None
tmp_widg.textChanged.connect(self.spnbox_changed)
# tmp_widg.tmp_lst = None
tmp_str += " " + str(
obj.extract())
if tmp_str is not None:
tmp_widg.local_path = str(obj.full_path())
# tmp_h_box.addStretch()
tmp_h_box.addWidget(tmp_widg)
self.lst_var_widg.append(tmp_widg)
self.bg_box.addLayout(tmp_h_box)
# debugging = '''
logger.debug("Non added parameters:")
for lin_to_print in non_added_lst:
logger.debug(lin_to_print)
class ScoringDialog(QWidget):
"""a dialog for entering the scores"""
# pylint: disable=too-many-instance-attributes
def __init__(self, scene):
QWidget.__init__(self)
self.scene = scene
decorateWindow(self, i18n('Scoring for this Hand'))
self.nameLabels = [None] * 4
self.spValues = [None] * 4
self.windLabels = [None] * 4
self.wonBoxes = [None] * 4
self.detailsLayout = [None] * 4
self.details = [None] * 4
self.__tilePixMaps = []
self.__meldPixMaps = []
grid = QGridLayout(self)
pGrid = QGridLayout()
grid.addLayout(pGrid, 0, 0, 2, 1)
pGrid.addWidget(QLabel(i18nc('kajongg', "Player")), 0, 0)
pGrid.addWidget(QLabel(i18nc('kajongg', "Wind")), 0, 1)
pGrid.addWidget(QLabel(i18nc('kajongg', 'Score')), 0, 2)
pGrid.addWidget(QLabel(i18n("Winner")), 0, 3)
self.detailTabs = QTabWidget()
self.detailTabs.setDocumentMode(True)
pGrid.addWidget(self.detailTabs, 0, 4, 8, 1)
for idx in range(4):
self.setupUiForPlayer(pGrid, idx)
self.draw = QCheckBox(i18nc('kajongg', 'Draw'))
self.draw.clicked.connect(self.wonChanged)
btnPenalties = QPushButton(i18n("&Penalties"))
btnPenalties.clicked.connect(self.penalty)
self.btnSave = QPushButton(i18n('&Save Hand'))
self.btnSave.clicked.connect(self.game.nextScoringHand)
self.btnSave.setEnabled(False)
self.setupUILastTileMeld(pGrid)
pGrid.setRowStretch(87, 10)
pGrid.addWidget(self.draw, 7, 3)
self.cbLastTile.currentIndexChanged.connect(self.slotLastTile)
self.cbLastMeld.currentIndexChanged.connect(self.slotInputChanged)
btnBox = QHBoxLayout()
btnBox.addWidget(btnPenalties)
btnBox.addWidget(self.btnSave)
pGrid.addLayout(btnBox, 8, 4)
StateSaver(self)
self.refresh()
@property
def game(self):
"""proxy"""
return self.scene.game
def setupUILastTileMeld(self, pGrid):
"""setup UI elements for last tile and last meld"""
self.lblLastTile = QLabel(i18n('&Last Tile:'))
self.cbLastTile = QComboBox()
self.cbLastTile.setMinimumContentsLength(1)
vpol = QSizePolicy()
vpol.setHorizontalPolicy(QSizePolicy.Fixed)
self.cbLastTile.setSizePolicy(vpol)
self.cbLastTile.setSizeAdjustPolicy(
QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastTile.setBuddy(self.cbLastTile)
self.lblLastMeld = QLabel(i18n('L&ast Meld:'))
self.prevLastTile = None
self.cbLastMeld = QComboBox()
self.cbLastMeld.setMinimumContentsLength(1)
self.cbLastMeld.setSizePolicy(vpol)
self.cbLastMeld.setSizeAdjustPolicy(
QComboBox.AdjustToMinimumContentsLengthWithIcon)
self.lblLastMeld.setBuddy(self.cbLastMeld)
self.comboTilePairs = set()
pGrid.setRowStretch(6, 5)
pGrid.addWidget(self.lblLastTile, 7, 0, 1, 2)
pGrid.addWidget(self.cbLastTile, 7, 2, 1, 1)
pGrid.addWidget(self.lblLastMeld, 8, 0, 1, 2)
pGrid.addWidget(self.cbLastMeld, 8, 2, 1, 2)
def setupUiForPlayer(self, pGrid, idx):
"""setup UI elements for a player"""
self.spValues[idx] = QSpinBox()
self.nameLabels[idx] = QLabel()
self.nameLabels[idx].setBuddy(self.spValues[idx])
self.windLabels[idx] = WindLabel()
pGrid.addWidget(self.nameLabels[idx], idx + 2, 0)
pGrid.addWidget(self.windLabels[idx], idx + 2, 1)
pGrid.addWidget(self.spValues[idx], idx + 2, 2)
self.wonBoxes[idx] = QCheckBox("")
pGrid.addWidget(self.wonBoxes[idx], idx + 2, 3)
self.wonBoxes[idx].clicked.connect(self.wonChanged)
self.spValues[idx].valueChanged.connect(self.slotInputChanged)
detailTab = QWidget()
self.detailTabs.addTab(detailTab, '')
self.details[idx] = QWidget()
detailTabLayout = QVBoxLayout(detailTab)
detailTabLayout.addWidget(self.details[idx])
detailTabLayout.addStretch()
self.detailsLayout[idx] = QVBoxLayout(self.details[idx])
def refresh(self):
"""reload game"""
self.clear()
game = self.game
self.setVisible(game is not None and not game.finished())
if game:
for idx, player in enumerate(game.players):
for child in self.details[idx].children():
if isinstance(child, RuleBox):
child.hide()
self.detailsLayout[idx].removeWidget(child)
del child
if game:
self.spValues[idx].setRange(0, game.ruleset.limit or 99999)
self.nameLabels[idx].setText(player.localName)
self.refreshWindLabels()
self.detailTabs.setTabText(idx, player.localName)
player.manualRuleBoxes = [
RuleBox(x) for x in game.ruleset.allRules
if x.hasSelectable
]
for ruleBox in player.manualRuleBoxes:
self.detailsLayout[idx].addWidget(ruleBox)
ruleBox.clicked.connect(self.slotInputChanged)
player.refreshManualRules()
def show(self):
"""only now compute content"""
if self.game and not self.game.finished():
self.slotInputChanged()
QWidget.show(self)
def penalty(self):
"""penalty button clicked"""
dlg = PenaltyDialog(self.game)
dlg.exec_()
def slotLastTile(self):
"""called when the last tile changes"""
newLastTile = self.computeLastTile()
if not newLastTile:
return
if self.prevLastTile and self.prevLastTile.isExposed != newLastTile.isExposed:
# state of last tile (concealed/exposed) changed:
# for all checked boxes check if they still are applicable
winner = self.game.winner
if winner:
for box in winner.manualRuleBoxes:
if box.isChecked():
box.setChecked(False)
if winner.hand.manualRuleMayApply(box.rule):
box.setChecked(True)
self.prevLastTile = newLastTile
self.fillLastMeldCombo()
self.slotInputChanged()
def computeLastTile(self):
"""returns the currently selected last tile"""
idx = self.cbLastTile.currentIndex()
if idx >= 0:
return self.cbLastTile.itemData(idx)
def clickedPlayerIdx(self, checkbox):
"""the player whose box has been clicked"""
for idx in range(4):
if checkbox == self.wonBoxes[idx]:
return idx
assert False
def wonChanged(self):
"""if a new winner has been defined, uncheck any previous winner"""
newWinner = None
if self.sender() != self.draw:
clicked = self.clickedPlayerIdx(self.sender())
if self.wonBoxes[clicked].isChecked():
newWinner = self.game.players[clicked]
else:
newWinner = None
self.game.winner = newWinner
for idx in range(4):
if newWinner != self.game.players[idx]:
self.wonBoxes[idx].setChecked(False)
if newWinner:
self.draw.setChecked(False)
self.fillLastTileCombo()
self.slotInputChanged()
def updateManualRules(self):
"""enable/disable them"""
# if an exclusive rule has been activated, deactivate it for
# all other players
ruleBox = self.sender()
if isinstance(
ruleBox,
RuleBox) and ruleBox.isChecked() and ruleBox.rule.exclusive():
for idx, player in enumerate(self.game.players):
if ruleBox.parentWidget() != self.details[idx]:
for pBox in player.manualRuleBoxes:
if pBox.rule.name == ruleBox.rule.name:
pBox.setChecked(False)
try:
newState = bool(self.game.winner.handBoard.uiTiles)
except AttributeError:
newState = False
self.lblLastTile.setEnabled(newState)
self.cbLastTile.setEnabled(newState)
self.lblLastMeld.setEnabled(newState)
self.cbLastMeld.setEnabled(newState)
if self.game:
for player in self.game.players:
player.refreshManualRules(self.sender())
def clear(self):
"""prepare for next hand"""
if self.game:
for idx, player in enumerate(self.game.players):
self.spValues[idx].clear()
self.spValues[idx].setValue(0)
self.wonBoxes[idx].setChecked(False)
player.payment = 0
player.invalidateHand()
for box in self.wonBoxes:
box.setVisible(False)
self.draw.setChecked(False)
self.updateManualRules()
if self.game is None:
self.hide()
else:
self.refreshWindLabels()
self.computeScores()
self.spValues[0].setFocus()
self.spValues[0].selectAll()
def refreshWindLabels(self):
"""update their wind and prevailing"""
for idx, player in enumerate(self.game.players):
self.windLabels[idx].wind = player.wind
self.windLabels[idx].roundsFinished = self.game.roundsFinished
def computeScores(self):
"""if tiles have been selected, compute their value"""
# pylint: disable=too-many-branches
# too many branches
if not self.game:
return
if self.game.finished():
self.hide()
return
for nameLabel, wonBox, spValue, player in zip(self.nameLabels,
self.wonBoxes,
self.spValues,
self.game.players):
with BlockSignals([spValue, wonBox]):
# we do not want that change to call computeScores again
if player.handBoard and player.handBoard.uiTiles:
spValue.setEnabled(False)
nameLabel.setBuddy(wonBox)
for _ in range(10):
prevTotal = player.handTotal
player.invalidateHand()
wonBox.setVisible(player.hand.won)
if not wonBox.isVisibleTo(self) and wonBox.isChecked():
wonBox.setChecked(False)
self.game.winner = None
elif prevTotal == player.handTotal:
break
player.refreshManualRules()
spValue.setValue(player.handTotal)
else:
if not spValue.isEnabled():
spValue.clear()
spValue.setValue(0)
spValue.setEnabled(True)
nameLabel.setBuddy(spValue)
wonBox.setVisible(
player.handTotal >= self.game.ruleset.minMJTotal())
if not wonBox.isVisibleTo(self) and wonBox.isChecked():
wonBox.setChecked(False)
if not wonBox.isVisibleTo(self) and player is self.game.winner:
self.game.winner = None
if Internal.scene.explainView:
Internal.scene.explainView.refresh()
def __lastMeldContent(self):
"""prepare content for lastmeld combo"""
lastTiles = set()
winnerTiles = []
if self.game.winner and self.game.winner.handBoard:
winnerTiles = self.game.winner.handBoard.uiTiles
pairs = []
for meld in self.game.winner.hand.melds:
if len(meld) < 4:
pairs.extend(meld)
for tile in winnerTiles:
if tile.tile in pairs and not tile.isBonus:
lastTiles.add(tile.tile)
return lastTiles, winnerTiles
def __fillLastTileComboWith(self, lastTiles, winnerTiles):
"""fill last meld combo with prepared content"""
self.comboTilePairs = lastTiles
idx = self.cbLastTile.currentIndex()
if idx < 0:
idx = 0
indexedTile = self.cbLastTile.itemData(idx)
restoredIdx = None
self.cbLastTile.clear()
if not winnerTiles:
return
pmSize = winnerTiles[0].board.tileset.faceSize
pmSize = QSize(pmSize.width() * 0.5, pmSize.height() * 0.5)
self.cbLastTile.setIconSize(pmSize)
QPixmapCache.clear()
self.__tilePixMaps = []
shownTiles = set()
for tile in winnerTiles:
if tile.tile in lastTiles and tile.tile not in shownTiles:
shownTiles.add(tile.tile)
self.cbLastTile.addItem(
QIcon(tile.pixmapFromSvg(pmSize, withBorders=False)), '',
tile.tile)
if indexedTile is tile.tile:
restoredIdx = self.cbLastTile.count() - 1
if not restoredIdx and indexedTile:
# try again, maybe the tile changed between concealed and exposed
indexedTile = indexedTile.exposed
for idx in range(self.cbLastTile.count()):
if indexedTile is self.cbLastTile.itemData(idx).exposed:
restoredIdx = idx
break
if not restoredIdx:
restoredIdx = 0
self.cbLastTile.setCurrentIndex(restoredIdx)
self.prevLastTile = self.computeLastTile()
def clearLastTileCombo(self):
"""as the name says"""
self.comboTilePairs = None
self.cbLastTile.clear()
def fillLastTileCombo(self):
"""fill the drop down list with all possible tiles.
If the drop down had content before try to preserve the
current index. Even if the tile changed state meanwhile."""
if self.game is None:
return
lastTiles, winnerTiles = self.__lastMeldContent()
if self.comboTilePairs == lastTiles:
return
with BlockSignals(self.cbLastTile):
# we only want to emit the changed signal once
self.__fillLastTileComboWith(lastTiles, winnerTiles)
self.cbLastTile.currentIndexChanged.emit(0)
def __fillLastMeldComboWith(self, winnerMelds, indexedMeld, lastTile):
"""fill last meld combo with prepared content"""
winner = self.game.winner
faceWidth = winner.handBoard.tileset.faceSize.width() * 0.5
faceHeight = winner.handBoard.tileset.faceSize.height() * 0.5
restoredIdx = None
for meld in winnerMelds:
pixMap = QPixmap(faceWidth * len(meld), faceHeight)
pixMap.fill(Qt.transparent)
self.__meldPixMaps.append(pixMap)
painter = QPainter(pixMap)
for element in meld:
painter.drawPixmap(
0, 0,
winner.handBoard.tilesByElement(element)[0].pixmapFromSvg(
QSize(faceWidth, faceHeight), withBorders=False))
painter.translate(QPointF(faceWidth, 0.0))
self.cbLastMeld.addItem(QIcon(pixMap), '', str(meld))
if indexedMeld == str(meld):
restoredIdx = self.cbLastMeld.count() - 1
if not restoredIdx and indexedMeld:
# try again, maybe the meld changed between concealed and exposed
indexedMeld = indexedMeld.lower()
for idx in range(self.cbLastMeld.count()):
meldContent = str(self.cbLastMeld.itemData(idx))
if indexedMeld == meldContent.lower():
restoredIdx = idx
if lastTile not in meldContent:
lastTile = lastTile.swapped
assert lastTile in meldContent
with BlockSignals(self.cbLastTile
): # we want to continue right here
idx = self.cbLastTile.findData(lastTile)
self.cbLastTile.setCurrentIndex(idx)
break
if not restoredIdx:
restoredIdx = 0
self.cbLastMeld.setCurrentIndex(restoredIdx)
self.cbLastMeld.setIconSize(QSize(faceWidth * 3, faceHeight))
def fillLastMeldCombo(self):
"""fill the drop down list with all possible melds.
If the drop down had content before try to preserve the
current index. Even if the meld changed state meanwhile."""
with BlockSignals(self.cbLastMeld
): # we only want to emit the changed signal once
showCombo = False
idx = self.cbLastMeld.currentIndex()
if idx < 0:
idx = 0
indexedMeld = str(self.cbLastMeld.itemData(idx))
self.cbLastMeld.clear()
self.__meldPixMaps = []
if not self.game.winner:
return
if self.cbLastTile.count() == 0:
return
lastTile = Internal.scene.computeLastTile()
winnerMelds = [
m for m in self.game.winner.hand.melds
if len(m) < 4 and lastTile in m
]
assert len(winnerMelds), 'lastTile %s missing in %s' % (
lastTile, self.game.winner.hand.melds)
if len(winnerMelds) == 1:
self.cbLastMeld.addItem(QIcon(), '', str(winnerMelds[0]))
self.cbLastMeld.setCurrentIndex(0)
return
showCombo = True
self.__fillLastMeldComboWith(winnerMelds, indexedMeld, lastTile)
self.lblLastMeld.setVisible(showCombo)
self.cbLastMeld.setVisible(showCombo)
self.cbLastMeld.currentIndexChanged.emit(0)
def slotInputChanged(self):
"""some input fields changed: update"""
for player in self.game.players:
player.invalidateHand()
self.updateManualRules()
self.computeScores()
self.validate()
for player in self.game.players:
player.showInfo()
Internal.mainWindow.updateGUI()
def validate(self):
"""update the status of the OK button"""
game = self.game
if game:
valid = True
if game.winner and game.winner.handTotal < game.ruleset.minMJTotal(
):
valid = False
elif not game.winner and not self.draw.isChecked():
valid = False
self.btnSave.setEnabled(valid)
class LoginDlg(QDialog):
"""login dialog for server"""
def __init__(self):
"""self.servers is a list of tuples containing server and last playername"""
QDialog.__init__(self, None)
decorateWindow(self, i18nc('kajongg', 'Login'))
self.setupUi()
localName = i18nc('kajongg name for local game server',
Query.localServerName)
self.servers = Query(
'select url,lastname from server order by lasttime desc').records
servers = list(x[0] for x in self.servers
if x[0] != Query.localServerName)
# the first server combobox item should be default: either the last used server
# or localName for autoPlay
if localName not in servers:
servers.append(localName)
if 'kajongg.org' not in servers:
servers.append('kajongg.org')
if Internal.autoPlay:
demoHost = Options.host or localName
if demoHost in servers:
servers.remove(
demoHost
) # we want a unique list, it will be re-used for all following games
servers.insert(0, demoHost)
# in this process but they will not be autoPlay
self.cbServer.addItems(servers)
self.passwords = Query(
'select url, p.name, passwords.password from passwords, player p '
'where passwords.player=p.id').records
Players.load()
self.cbServer.editTextChanged.connect(self.serverChanged)
self.cbUser.editTextChanged.connect(self.userChanged)
self.serverChanged()
StateSaver(self)
def returns(self, dummyButton=None):
"""login data returned by this dialog"""
return (Url(self.url), self.username, self.password,
self.__defineRuleset())
def setupUi(self):
"""create all Ui elements but do not fill them"""
self.buttonBox = KDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
# Ubuntu 11.10 unity is a bit strange - without this, it sets focus on
# the cancel button (which it shows on the left). I found no obvious
# way to use setDefault and setAutoDefault for fixing this.
self.buttonBox.button(QDialogButtonBox.Ok).setFocus(True)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
vbox = QVBoxLayout(self)
self.grid = QFormLayout()
self.cbServer = QComboBox()
self.cbServer.setEditable(True)
self.grid.addRow(i18n('Game server:'), self.cbServer)
self.cbUser = QComboBox()
self.cbUser.setEditable(True)
self.grid.addRow(i18n('Username:'******'Password:'******'kajongg', 'Ruleset:'), self.cbRuleset)
vbox.addLayout(self.grid)
vbox.addWidget(self.buttonBox)
pol = QSizePolicy()
pol.setHorizontalPolicy(QSizePolicy.Expanding)
self.cbUser.setSizePolicy(pol)
self.__port = None
def serverChanged(self, dummyText=None):
"""the user selected a different server"""
records = Query(
'select player.name from player, passwords '
'where passwords.url=? and passwords.player = player.id',
(self.url, )).records
players = list(x[0] for x in records)
preferPlayer = Options.player
if preferPlayer:
if preferPlayer in players:
players.remove(preferPlayer)
players.insert(0, preferPlayer)
self.cbUser.clear()
self.cbUser.addItems(players)
if not self.cbUser.count():
user = KUser() if os.name == 'nt' else KUser(os.geteuid())
self.cbUser.addItem(user.fullName() or user.loginName())
if not preferPlayer:
userNames = [x[1] for x in self.servers if x[0] == self.url]
if userNames:
userIdx = self.cbUser.findText(userNames[0])
if userIdx >= 0:
self.cbUser.setCurrentIndex(userIdx)
showPW = bool(self.url) and not Url(self.url).isLocalHost
self.grid.labelForField(self.edPassword).setVisible(showPW)
self.edPassword.setVisible(showPW)
self.grid.labelForField(self.cbRuleset).setVisible(
not showPW and not Options.ruleset)
self.cbRuleset.setVisible(not showPW and not Options.ruleset)
if not showPW:
self.cbRuleset.clear()
if Options.ruleset:
self.cbRuleset.items = [Options.ruleset]
else:
self.cbRuleset.items = Ruleset.selectableRulesets(self.url)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(bool(self.url))
def __defineRuleset(self):
"""find out what ruleset to use"""
if Options.ruleset:
return Options.ruleset
elif Internal.autoPlay or bool(Options.host):
return Ruleset.selectableRulesets()[0]
else:
return self.cbRuleset.current
def userChanged(self, text):
"""the username has been changed, lookup password"""
if text == '':
self.edPassword.clear()
return
passw = None
for entry in self.passwords:
if entry[0] == self.url and entry[1] == text:
passw = entry[2]
if passw:
self.edPassword.setText(passw)
else:
self.edPassword.clear()
@property
def url(self):
"""abstracts the url of the dialog"""
return english(self.cbServer.currentText())
@property
def username(self):
"""abstracts the username of the dialog"""
return self.cbUser.currentText()
@property
def password(self):
"""abstracts the password of the dialog"""
return self.edPassword.text()
@password.setter
def password(self, password):
"""abstracts the password of the dialog"""
self.edPassword.setText(password)
def slotRefresh(self, tag):
self.clear()
if tag == None:
QComboBox.setEnabled(self, False)
else:
tagType = kuraapp.app.getObject("lng_tag", tag = tag).getTagTypeCode()
if int(tagType.isdomain) == True:
self.mode = DOMAIN
QComboBox.setEnabled(self, True)
QComboBox.setEditable(self, False)
rows = kuraapp.app.getObjects("lng_tagdomain", tag = tag)
for row in rows:
self.insertItem(row.description)
index = self.count()-1
self.index_to_key[index] = row.domainnr
self.key_to_index[row.domainnr]=index
elif int(tagType.isvalue) == True:
self.mode = VALUE
QComboBox.setEnabled(self, True)
QComboBox.setEditable(self, True)
self.insertItem("<New Value>")
if guiConf.ShowValueHint == True:
rows = kuraapp.app.getObjects(self.tagTableName,
tag = tag)
self.strlist=["<New Value>"]
for row in rows:
if row.value not in self.strlist:
self.strlist.append(row.value)
self.insertItem(row.value)
elif int(tagType.isreference)==True:
self.mode = REFERENCE
QComboBox.setEnabled(self, True)
QComboBox.setEditable(self, False)
rows = kuraapp.app.getObjects("lng_reference")
for row in rows:
self.insertItem(row.title + ", " + row.year +
", " + row.author)
index = self.count() - 1
self.index_to_key[index] = row.referencenr
self.key_to_index[row.referencenr] = index
else:
QComboBox.setEnabled(self, False)
QComboBox.setEditable(self, False)
def __init__(self, parent=None):
super(RefineSimplerParamTab, self).__init__()
# self.param_widget_parent = parent.param_widget_parent
localLayout = QVBoxLayout()
hbox_lay_scan_varying = QHBoxLayout()
label_scan_varying = QLabel("Scan Varying Refinement")
hbox_lay_scan_varying.addWidget(label_scan_varying)
box_scan_varying = QComboBox()
box_scan_varying.local_path = "refinement.parameterisation.scan_varying"
box_scan_varying.tmp_lst = []
box_scan_varying.tmp_lst.append("True")
box_scan_varying.tmp_lst.append("False")
box_scan_varying.tmp_lst.append("Auto")
for lst_itm in box_scan_varying.tmp_lst:
box_scan_varying.addItem(lst_itm)
box_scan_varying.setCurrentIndex(2)
box_scan_varying.currentIndexChanged.connect(self.combobox_changed)
hbox_lay_scan_varying.addWidget(box_scan_varying)
localLayout.addLayout(hbox_lay_scan_varying)
###########################################################################
hbox_lay_outlier_algorithm = QHBoxLayout()
label_outlier_algorithm = QLabel("Outlier Rejection Algorithm")
hbox_lay_outlier_algorithm.addWidget(label_outlier_algorithm)
box_outlier_algorithm = QComboBox()
box_outlier_algorithm.local_path = "refinement.reflections.outlier.algorithm"
box_outlier_algorithm.tmp_lst = []
box_outlier_algorithm.tmp_lst.append("null")
box_outlier_algorithm.tmp_lst.append("auto")
box_outlier_algorithm.tmp_lst.append("mcd")
box_outlier_algorithm.tmp_lst.append("tukey")
box_outlier_algorithm.tmp_lst.append("sauter_poon")
for lst_itm in box_outlier_algorithm.tmp_lst:
box_outlier_algorithm.addItem(lst_itm)
box_outlier_algorithm.setCurrentIndex(1)
box_outlier_algorithm.currentIndexChanged.connect(
self.combobox_changed)
hbox_lay_outlier_algorithm.addWidget(box_outlier_algorithm)
localLayout.addLayout(hbox_lay_outlier_algorithm)
self.inner_reset_btn = ResetButton()
localLayout.addWidget(self.inner_reset_btn)
localLayout.addStretch()
self.setLayout(localLayout)
self.lst_var_widg = []
self.lst_var_widg.append(box_scan_varying)
self.lst_var_widg.append(label_scan_varying)
# self.lst_var_widg.append(box_beam_fix)
# self.lst_var_widg.append(label_beam_fix)
# self.lst_var_widg.append(box_crystal_fix)
# self.lst_var_widg.append(label_crystal_fix)
# self.lst_var_widg.append(box_detector_fix)
# self.lst_var_widg.append(label_detector_fix)
# self.lst_var_widg.append(box_goniometer_fix)
# self.lst_var_widg.append(label_goniometer_fix)
self.lst_var_widg.append(box_outlier_algorithm)
self.lst_var_widg.append(label_outlier_algorithm)
def setCurrentItem(self, key):
if self.key_to_index.has_key(key):
QComboBox.setCurrentItem(self, self.key_to_index[key])
def __init__(self, parent=None):
super(ScaleSimplerParamTab, self).__init__()
localLayout = QVBoxLayout()
hbox_lay_mod = QHBoxLayout()
label_mod = QLabel("Model")
hbox_lay_mod.addWidget(label_mod)
box_mod = QComboBox()
box_mod.local_path = "model"
box_mod.tmp_lst = []
box_mod.tmp_lst.append("physical")
box_mod.tmp_lst.append("array")
box_mod.tmp_lst.append("KB")
for lst_itm in box_mod.tmp_lst:
box_mod.addItem(lst_itm)
box_mod.currentIndexChanged.connect(self.combobox_changed)
hbox_lay_mod.addWidget(box_mod)
hbox_lay_wgh_opt_err = QHBoxLayout()
label_wgh_opt_err = QLabel("Optimise Errors Model")
hbox_lay_wgh_opt_err.addWidget(label_wgh_opt_err)
'''
weighting {
error_model {
error_model = *basic None
'''
box_wgh_opt_err = QComboBox()
box_wgh_opt_err.local_path = "weighting.error_model.error_model"
box_wgh_opt_err.tmp_lst = []
box_wgh_opt_err.tmp_lst.append("basic")
box_wgh_opt_err.tmp_lst.append("None")
for lst_itm in box_wgh_opt_err.tmp_lst:
box_wgh_opt_err.addItem(lst_itm)
box_wgh_opt_err.currentIndexChanged.connect(self.combobox_changed)
hbox_lay_wgh_opt_err.addWidget(box_wgh_opt_err)
hbox_d_min = QHBoxLayout()
d_min_label = QLabel("d_min")
d_min_spn_bx = QDoubleSpinBox()
d_min_spn_bx.local_path = "cut_data.d_min"
d_min_spn_bx.setSpecialValueText("None")
d_min_spn_bx.setValue(0.0)
hbox_d_min.addWidget(d_min_label)
hbox_d_min.addWidget(d_min_spn_bx)
d_min_spn_bx.valueChanged.connect(self.spnbox_changed)
localLayout.addLayout(hbox_lay_mod)
localLayout.addLayout(hbox_lay_wgh_opt_err)
localLayout.addLayout(hbox_d_min)
self.inner_reset_btn = ResetButton()
localLayout.addWidget(self.inner_reset_btn)
localLayout.addStretch()
self.setLayout(localLayout)
self.lst_var_widg = []
self.lst_var_widg.append(box_mod)
self.lst_var_widg.append(label_mod)
self.lst_var_widg.append(box_wgh_opt_err)
self.lst_var_widg.append(label_wgh_opt_err)
self.lst_var_widg.append(d_min_spn_bx)
self.lst_var_widg.append(d_min_label)
def insertItem(self, text, index):
QComboBox.insertItem(self, text)
self.index_to_key [self.count() - 1] = index
self.key_to_index [index]=self.count() - 1
class ProstateTRUSNavUltrasound(UltraSound):
OFFLINE_VOLUME_FILENAME = "RecVol_Reference.mha"
SCOUT_VOLUME_FILENAME = "ScoutScan.mha"
LIVE_VOLUME_FILENAME = "LiveReconstructedVolume.mha"
RECORDING_FILENAME = "Recording.mha"
SCOUT_RECORDING_FILENAME = "ScoutScanRecording.mha"
LIVE_RECORDING_FILENAME = LIVE_VOLUME_FILENAME
SCOUT_VOLUME_NODE_NAME = "ScoutScan"
OFFLINE_VOLUME_NODE_NAME = "RecVol_Reference"
LIVE_VOLUME_NODE_NAME = "liveReconstruction"
APPLY_HOLE_FILLING_FOR_SNAPSHOT = False
SNAPSHOT_INTERVAL = 3
OUTPUT_VOLUME_SPACING = 3
LIVE_OUTPUT_VOLUME_SPACING = 1
@property
def roiNode(self):
return self._roiNode
@roiNode.setter
def roiNode(self, node):
self._roiNode=node
if node is not None:
self.startStopLiveReconstructionButton.setEnabled(True)
else:
self.startStopLiveReconstructionButton.setEnabled(False)
def __init__(self, guideletParent):
UltraSound.__init__(self, guideletParent)
self.parameterNode = guideletParent.parameterNode
self.parameterNodeObserver = None
self._roiNode = None
self.liveOutputSpacingValue = [self.LIVE_OUTPUT_VOLUME_SPACING, self.LIVE_OUTPUT_VOLUME_SPACING,
self.LIVE_OUTPUT_VOLUME_SPACING]
self.outputSpacing = [self.OUTPUT_VOLUME_SPACING, self.OUTPUT_VOLUME_SPACING, self.OUTPUT_VOLUME_SPACING]
self.roiOrigin = None
self.roiExtent = None
self.defaultParameterNode = None
self.logic = ProstateTRUSNavUltrasoundLogic()
def setupPanel(self, parentWidget):
logging.debug('ProstateTRUSNavUltrasound.setupPanel')
self.connectorNode = self.guideletParent.connectorNode
self.connectorNodeConnected = False
collapsibleButton = ctkCollapsibleButton()
collapsibleButton.setProperty('collapsedHeight', 20)
setButtonStyle(collapsibleButton, 2.0)
collapsibleButton.text = "Ultrasound"
parentWidget.addWidget(collapsibleButton)
ultrasoundLayout = QFormLayout(collapsibleButton)
ultrasoundLayout.setContentsMargins(12,4,4,4)
ultrasoundLayout.setSpacing(4)
self.connectDisconnectButton = QPushButton("Connect")
self.connectDisconnectButton.setToolTip("If clicked, connection OpenIGTLink")
hbox = QHBoxLayout()
hbox.addWidget(self.connectDisconnectButton)
ultrasoundLayout.addRow(hbox)
self.setupIcons()
self.captureIDSelector = QComboBox()
self.captureIDSelector.setToolTip("Pick capture device ID")
self.captureIDSelector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.volumeReconstructorIDSelector = QComboBox()
self.volumeReconstructorIDSelector.setToolTip( "Pick volume reconstructor device ID" )
self.volumeReconstructorIDSelector.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.startStopRecordingButton = QPushButton(" Start Recording")
self.startStopRecordingButton.setCheckable(True)
self.startStopRecordingButton.setIcon(self.recordIcon)
self.startStopRecordingButton.setEnabled(False)
self.startStopRecordingButton.setToolTip("If clicked, start recording")
self.startStopRecordingButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
recordParametersControlsLayout = QGridLayout()
self.filenameLabel = self.createLabel("Filename:", visible=False)
recordParametersControlsLayout.addWidget(self.filenameLabel, 1, 0)
# Offline Reconstruction
self.offlineReconstructButton = QPushButton(" Offline Reconstruction")
self.offlineReconstructButton.setCheckable(True)
self.offlineReconstructButton.setIcon(self.recordIcon)
self.offlineReconstructButton.setEnabled(False)
self.offlineReconstructButton.setToolTip("If clicked, reconstruct recorded volume")
self.offlineReconstructButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.offlineVolumeToReconstructSelector = QComboBox()
self.offlineVolumeToReconstructSelector.setEditable(True)
self.offlineVolumeToReconstructSelector.setToolTip( "Pick/set volume to reconstruct" )
self.offlineVolumeToReconstructSelector.visible = False
hbox = QHBoxLayout()
hbox.addWidget(self.startStopRecordingButton)
hbox.addWidget(self.offlineReconstructButton)
ultrasoundLayout.addRow(hbox)
# Scout scan (record and low resolution reconstruction) and live reconstruction
# Scout scan part
self.startStopScoutScanButton = QPushButton(" Scout scan\n Start recording")
self.startStopScoutScanButton.setCheckable(True)
self.startStopScoutScanButton.setIcon(self.recordIcon)
self.startStopScoutScanButton.setToolTip("If clicked, start recording")
self.startStopScoutScanButton.setEnabled(False)
self.startStopScoutScanButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.startStopLiveReconstructionButton = QPushButton(" Start live reconstruction")
self.startStopLiveReconstructionButton.setCheckable(True)
self.startStopLiveReconstructionButton.setIcon(self.recordIcon)
self.startStopLiveReconstructionButton.setToolTip("If clicked, start live reconstruction")
self.startStopLiveReconstructionButton.setEnabled(False)
self.startStopLiveReconstructionButton.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.displayRoiButton = QToolButton()
self.displayRoiButton.setCheckable(True)
self.displayRoiButton.setIcon(self.visibleOffIcon)
self.displayRoiButton.setToolTip("If clicked, display ROI")
hbox = QHBoxLayout()
hbox.addWidget(self.startStopScoutScanButton)
hbox.addWidget(self.startStopLiveReconstructionButton)
# hbox.addWidget(self.displayRoiButton)
ultrasoundLayout.addRow(hbox)
self.snapshotTimer = QTimer()
self.snapshotTimer.setSingleShot(True)
self.onParameterSetSelected()
return collapsibleButton
def setupResliceDriver(self):
layoutManager = slicer.app.layoutManager()
# Show ultrasound in red view.
redSlice = layoutManager.sliceWidget('Red')
redSliceLogic = redSlice.sliceLogic()
redSliceLogic.GetSliceCompositeNode().SetBackgroundVolumeID(self.liveUltrasoundNode_Reference.GetID())
resliceLogic = slicer.modules.volumereslicedriver.logic()
if resliceLogic:
redNode = slicer.util.getNode('vtkMRMLSliceNodeRed')
redNode.SetSliceResolutionMode(slicer.vtkMRMLSliceNode.SliceResolutionMatchVolumes)
resliceLogic.SetDriverForSlice(self.liveUltrasoundNode_Reference.GetID(), redNode)
resliceLogic.SetModeForSlice(6, redNode) # Transverse mode, default for PLUS ultrasound.
else:
logging.warning('Logic not found for Volume Reslice Driver')
def createCollapsibleButton(self, text, collapsed=False):
collapsibleButton = ctkCollapsibleButton()
collapsibleButton.text = text
collapsibleButton.collapsed = collapsed
return collapsibleButton
def createLabel(self, text, visible=True):
label = QLabel()
label.setText(text)
label.visible = visible
return label
def setupConnections(self):
self.startStopRecordingButton.connect('clicked(bool)', self.onStartStopRecordingButtonClicked)
self.offlineReconstructButton.connect('clicked(bool)', self.onReconstVolume)
self.startStopScoutScanButton.connect('clicked(bool)', self.onStartStopScoutScanButtonClicked)
self.startStopLiveReconstructionButton.connect('clicked(bool)', self.onStartStopLiveReconstructionButtonClicked)
self.displayRoiButton.connect('clicked(bool)', self.onDisplayRoiButtonClicked)
self.captureIDSelector.connect('currentIndexChanged(QString)', self.updateParameterNodeFromGui)
self.volumeReconstructorIDSelector.connect('currentIndexChanged(QString)', self.updateParameterNodeFromGui)
self.offlineVolumeToReconstructSelector.connect('currentIndexChanged(int)', self.updateParameterNodeFromGui)
self.displayRoiButton.connect('clicked(bool)', self.updateParameterNodeFromGui)
self.snapshotTimer.timeout.connect(self.onRequestVolumeReconstructionSnapshot)
self.connectDisconnectButton.connect('clicked(bool)', self.onConnectDisconnectButtonClicked)
def disconnect(self):
self.startStopRecordingButton.disconnect('clicked(bool)', self.onStartStopRecordingButtonClicked)
self.offlineReconstructButton.disconnect('clicked(bool)', self.onReconstVolume)
self.startStopScoutScanButton.disconnect('clicked(bool)', self.onStartStopScoutScanButtonClicked)
self.startStopLiveReconstructionButton.disconnect('clicked(bool)', self.onStartStopLiveReconstructionButtonClicked)
self.displayRoiButton.disconnect('clicked(bool)', self.onDisplayRoiButtonClicked)
self.captureIDSelector.disconnect('currentIndexChanged(QString)', self.updateParameterNodeFromGui)
self.volumeReconstructorIDSelector.disconnect('currentIndexChanged(QString)', self.updateParameterNodeFromGui)
self.offlineVolumeToReconstructSelector.disconnect('currentIndexChanged(int)', self.updateParameterNodeFromGui)
self.displayRoiButton.disconnect('clicked(bool)', self.updateParameterNodeFromGui)
self.snapshotTimer.timeout.disconnect(self.onRequestVolumeReconstructionSnapshot)
self.connectDisconnectButton.disconnect('clicked(bool)', self.onConnectDisconnectButtonClicked)
def setupIcons(self):
self.plusRemoteModuleDirectoryPath = slicer.modules.plusremote.path.replace("PlusRemote.py", "")
self.recordIcon = QIcon(self.plusRemoteModuleDirectoryPath + '/Resources/Icons/icon_Record.png')
self.stopIcon = QIcon(self.plusRemoteModuleDirectoryPath + '/Resources/Icons/icon_Stop.png')
self.waitIcon = QIcon(self.plusRemoteModuleDirectoryPath + '/Resources/Icons/icon_Wait.png')
self.visibleOffIcon = QIcon(":Icons\VisibleOff.png")
self.visibleOnIcon = QIcon(":Icons\VisibleOn.png")
def onParameterSetSelected(self):
# Set up default values for new nodes
if self.parameterNode:
self.plusRemoteLogic.setDefaultParameters(self.parameterNode)
self.updateGuiFromParameterNode()
def updateGuiFromParameterNode(self):
self.parameterVolumeList = {'OfflineVolumeToReconstruct': self.offlineVolumeToReconstructSelector}
for parameter in self.parameterVolumeList:
if self.parameterNode.GetParameter(parameter):
self.parameterVolumeList[parameter].blockSignals(True)
self.parameterVolumeList[parameter].blockSignals(False)
if self.parameterNode.GetParameter('CaptureID'):
self.captureIDSelector.blockSignals(True)
for i in range(0, self.captureIDSelector.count):
if self.parameterNode.GetParameter('CaptureID') == self.captureIDSelector.itemText(i):
self.captureIDSelector.setCurrentIndex(int(self.parameterNode.GetParameter('CaptureIdIndex')))
self.captureIDSelector.blockSignals(False)
if self.parameterNode.GetParameter('VolumeReconstructor'):
self.volumeReconstructorIDSelector.blockSignals(True)
for i in range(0, self.volumeReconstructorIDSelector.count):
if self.parameterNode.GetParameter('VolumeReconstructor') == self.volumeReconstructorIDSelector.itemText(i):
self.volumeReconstructorIDSelector.setCurrentIndex(int(self.parameterNode.GetParameter('VolumeReconstructorIndex')))
self.volumeReconstructorIDSelector.blockSignals(False)
self.roiNode = self.parameterNode.GetNthNodeReference('ROI', 0)
def updateParameterNodeFromGui(self):
#Update parameter node value to save when user change value in the interface
if not self.parameterNode:
return
self.parametersList = {'CaptureID': self.captureIDSelector.currentText,
'CaptureIdIndex': self.captureIDSelector.currentIndex,
'VolumeReconstructor': self.volumeReconstructorIDSelector.currentText,
'VolumeReconstructorIndex': self.volumeReconstructorIDSelector.currentIndex,
'OfflineVolumeToReconstruct': self.offlineVolumeToReconstructSelector.currentIndex}
for parameter in self.parametersList:
self.parameterNode.SetParameter(parameter, str(self.parametersList[parameter]))
if self.roiNode:
roiNodeID = self.roiNode.GetID()
self.parameterNode.SetNthNodeReferenceID('ROI', 0, roiNodeID)
#
# Connector observation and actions
#
def onConnectorNodeConnected(self):
logging.debug("ProstateTrusUltrasound:onConnectorNodeConnected")
self.connectorNodeConnected = True
self.captureIDSelector.setDisabled(False)
self.volumeReconstructorIDSelector.setDisabled(False)
self.plusRemoteLogic.getCaptureDeviceIds(self.connectorNode.GetID(),
self.onGetCaptureDeviceCommandResponseReceived)
self.plusRemoteLogic.getVolumeReconstructorDeviceIds(self.connectorNode.GetID(),
self.onGetVolumeReconstructorDeviceCommandResponseReceived)
self.connectDisconnectButton.setText("Disconnect")
def onConnectorNodeDisconnected(self):
logging.debug("ProstateTrusUltrasound:onConnectorNodeDisconnected")
self.connectorNodeConnected = False
self.startStopRecordingButton.setEnabled(False)
self.startStopScoutScanButton.setEnabled(False)
self.startStopLiveReconstructionButton.setEnabled(False)
self.offlineReconstructButton.setEnabled(False)
self.captureIDSelector.setDisabled(True)
self.volumeReconstructorIDSelector.setDisabled(True)
self.connectDisconnectButton.setText("Connect")
def getLiveVolumeRecNode(self):
liveVolumeRecNode = slicer.util.getNode(self.LIVE_VOLUME_NODE_NAME)
return liveVolumeRecNode
def getOfflineVolumeRecNode(self):
offlineVolumeRecNode = slicer.util.getNode(self.OFFLINE_VOLUME_NODE_NAME)
return offlineVolumeRecNode
def getScoutVolumeNode(self):
scoutScanVolumeNode = slicer.util.getNode(self.SCOUT_VOLUME_NODE_NAME)
return scoutScanVolumeNode
def onConnectDisconnectButtonClicked(self):
if self.connectorNode.GetState() == slicer.vtkMRMLIGTLConnectorNode.STATE_CONNECTED:
self.connectorNode.Stop()
else:
self.connectorNode.Start()
def onStartStopRecordingButtonClicked(self):
if self.startStopRecordingButton.isChecked():
self.startStopRecordingButton.setText(" Stop Recording")
self.startStopRecordingButton.setIcon(self.stopIcon)
self.startStopRecordingButton.setToolTip( "If clicked, stop recording" )
self.onStartRecording(self.generateRecordingOutputFilename())
else:
self.startStopRecordingButton.setText(" Start Recording")
self.startStopRecordingButton.setIcon(self.recordIcon)
self.startStopRecordingButton.setToolTip( "If clicked, start recording" )
self.onStopRecording(self.onVolumeRecorded)
def onStartStopScoutScanButtonClicked(self):
if self.startStopScoutScanButton.isChecked():
self.startStopScoutScanButton.setText(" Scout Scan\n Stop Recording and Reconstruct Recorded Volume")
self.startStopScoutScanButton.setIcon(self.stopIcon)
self.startStopScoutScanButton.setToolTip( "If clicked, stop recording and reconstruct recorded volume" )
self.onStartRecording(self.generateScoutRecordingOutputFilename())
else:
self.onStopRecording(self.onScoutVolumeRecorded)
def onStartStopLiveReconstructionButtonClicked(self):
if self.startStopLiveReconstructionButton.isChecked():
if self.roiNode:
self.roiOrigin, self.roiExtent = self.logic.updateVolumeOriginAndExtentFromROI(self.LIVE_OUTPUT_VOLUME_SPACING,
self.roiNode)
self.startStopLiveReconstructionButton.setText(" Stop Live Reconstruction")
self.startStopLiveReconstructionButton.setIcon(self.stopIcon)
self.startStopLiveReconstructionButton.setToolTip( "If clicked, stop live reconstruction" )
self.onStartRecording(self.getLiveRecordingOutputFilename())
self.onStartReconstruction()
else:
self.startStopLiveReconstructionButton.setText(" Start Live Reconstruction")
self.startStopLiveReconstructionButton.setIcon(self.recordIcon)
self.startStopLiveReconstructionButton.setToolTip( "If clicked, start live reconstruction" )
self.onStopRecording(self.printCommandResponse)
self.onStopReconstruction()
def onDisplayRoiButtonClicked(self):
if self.displayRoiButton.isChecked():
self.displayRoiButton.setIcon(self.visibleOnIcon)
self.displayRoiButton.setToolTip("If clicked, hide ROI")
if self.roiNode:
self.roiNode.SetDisplayVisibility(1)
else:
self.displayRoiButton.setIcon(self.visibleOffIcon)
self.displayRoiButton.setToolTip("If clicked, display ROI")
if self.roiNode:
self.roiNode.SetDisplayVisibility(0)
def generateRecordingOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(self.RECORDING_FILENAME)
def generateScoutRecordingOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(self.SCOUT_RECORDING_FILENAME)
def getLiveRecordingOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(self.LIVE_RECORDING_FILENAME)
def getLiveReconstructionOutputFilename(self):
return self.plusRemoteLogic.addTimestampToFilename(self.LIVE_VOLUME_FILENAME)
def onStartRecording(self, filename):
self.plusRemoteLogic.startRecording(self.connectorNode.GetID(), self.captureIDSelector.currentText,
filename, self.printCommandResponse)
def onStopRecording(self, callback):
self.plusRemoteLogic.stopRecording(self.connectorNode.GetID(), self.captureIDSelector.currentText, callback)
def onStartReconstruction(self):
if self.roiNode:
self.roiOrigin, self.roiExtent = self.logic.updateVolumeOriginAndExtentFromROI(self.LIVE_OUTPUT_VOLUME_SPACING,
self.roiNode)
self.plusRemoteLogic.startVolumeReconstuction(self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.liveOutputSpacingValue, self.roiOrigin,
self.roiExtent, self.printCommandResponse,
self.getLiveReconstructionOutputFilename(), self.LIVE_VOLUME_NODE_NAME)
# Set up timer for requesting snapshot
self.snapshotTimer.start(self.SNAPSHOT_INTERVAL*1000)
def onStopReconstruction(self):
self.snapshotTimer.stop()
self.plusRemoteLogic.stopVolumeReconstruction(self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.onVolumeLiveReconstructed,
self.getLiveReconstructionOutputFilename(),
self.LIVE_VOLUME_NODE_NAME)
def onReconstVolume(self):
self.offlineReconstructButton.setIcon(self.waitIcon)
self.offlineReconstructButton.setText(" Offline Reconstruction in progress ...")
self.offlineReconstructButton.setEnabled(False)
self.plusRemoteLogic.reconstructRecorded(self.connectorNode.GetID(), self.volumeReconstructorIDSelector.currentText,
self.offlineVolumeToReconstructSelector.currentText, self.outputSpacing,
self.onVolumeReconstructed, self.OFFLINE_VOLUME_FILENAME,
self.OFFLINE_VOLUME_NODE_NAME)
def onScoutScanReconstVolume(self):
self.startStopScoutScanButton.setIcon(self.waitIcon)
self.startStopScoutScanButton.setText(" Scout Scan\n Reconstruction in progress ...")
self.startStopScoutScanButton.setEnabled(False)
self.plusRemoteLogic.reconstructRecorded(self.connectorNode.GetID(), self.volumeReconstructorIDSelector.currentText,
self.lastScoutRecordingOutputFilename, self.outputSpacing,
self.onScoutVolumeReconstructed, self.SCOUT_VOLUME_FILENAME,
self.SCOUT_VOLUME_NODE_NAME)
def onRequestVolumeReconstructionSnapshot(self, stopFlag = ""):
self.plusRemoteLogic.getVolumeReconstructionSnapshot(self.connectorNode.GetID(),
self.volumeReconstructorIDSelector.currentText,
self.LIVE_VOLUME_FILENAME,
self.LIVE_VOLUME_NODE_NAME,
self.APPLY_HOLE_FILLING_FOR_SNAPSHOT, self.onSnapshotAcquired)
def executeCommandDelayed(self, method, delay=100):
# Order of OpenIGTLink message receiving and processing is not guaranteed to be the same
# therefore we wait a bit to make sure the image message is processed as well
QTimer.singleShot(delay, method)
def printCommandResponse(self, command, q):
statusText = "Command {0} [{1}]: {2}\n".format(command.GetCommandName(), command.GetID(),
command.StatusToString(command.GetStatus()))
if command.GetResponseMessage():
statusText = statusText + command.GetResponseMessage()
elif command.GetResponseText():
statusText = statusText + command.GetResponseText()
logging.debug(statusText)
def onGetCaptureDeviceCommandResponseReceived(self, command, q):
self.printCommandResponse(command, q)
if command.GetStatus() != command.CommandSuccess:
return
captureDeviceIdsListString = command.GetResponseMessage()
if captureDeviceIdsListString:
captureDevicesIdsList = captureDeviceIdsListString.split(",")
else:
captureDevicesIdsList = []
for i in range(0,len(captureDevicesIdsList)):
if self.captureIDSelector.findText(captureDevicesIdsList[i]) == -1:
self.captureIDSelector.addItem(captureDevicesIdsList[i])
def onGetVolumeReconstructorDeviceCommandResponseReceived(self, command, q):
self.printCommandResponse(command, q)
if command.GetStatus() != command.CommandSuccess:
return
volumeReconstructorDeviceIdsListString = command.GetResponseMessage()
if volumeReconstructorDeviceIdsListString:
volumeReconstructorDeviceIdsList = volumeReconstructorDeviceIdsListString.split(",")
else:
volumeReconstructorDeviceIdsList = []
self.volumeReconstructorIDSelector.clear()
self.volumeReconstructorIDSelector.addItems(volumeReconstructorDeviceIdsList)
self.startStopRecordingButton.setEnabled(True)
self.offlineReconstructButton.setEnabled(True)
self.startStopScoutScanButton.setEnabled(True)
if self.roiNode:
self.startStopLiveReconstructionButton.setEnabled(True)
def onVolumeRecorded(self, command, q):
self.printCommandResponse(command, q)
self.offlineReconstructButton.setEnabled(True)
volumeToReconstructFileName = os.path.basename(command.GetResponseMessage())
self.offlineVolumeToReconstructSelector.insertItem(0,volumeToReconstructFileName)
self.offlineVolumeToReconstructSelector.setCurrentIndex(0)
def onScoutVolumeRecorded(self, command, q):
self.printCommandResponse(command,q)
self.offlineReconstructButton.setEnabled(True)
if command.GetStatus() == command.CommandExpired:
logging.fatal("Scout Volume Recording: Timeout while waiting for volume reconstruction result")
return
if command.GetStatus() == command.CommandSuccess:
self.lastScoutRecordingOutputFilename = os.path.basename(command.GetResponseMessage())
self.onScoutScanReconstVolume()
def onVolumeReconstructed(self, command, q):
self.printCommandResponse(command,q)
self.offlineReconstructButton.setIcon(self.recordIcon)
self.offlineReconstructButton.setText("Offline Reconstruction")
self.offlineReconstructButton.setEnabled(True)
self.offlineReconstructButton.setChecked(False)
if command.GetStatus() == command.CommandExpired:
# volume reconstruction command timed out
logging.fatal("Volume Reconstruction: Timeout while waiting for volume reconstruction result")
return
if command.GetStatus() != command.CommandSuccess:
logging.debug("Volume Reconstruction: " + command.GetResponseMessage())
return
self.executeCommandDelayed(self.onVolumeReconstructedFinalize)
def onVolumeReconstructedFinalize(self):
applicationLogic = slicer.app.applicationLogic()
applicationLogic.FitSliceToAll()
self.guideletParent.showVolumeRendering(self.getOfflineVolumeRecNode())
def onScoutVolumeReconstructed(self, command, q):
self.printCommandResponse(command,q)
if command.GetStatus() == command.CommandExpired:
logging.fatal("Scout Volume Reconstruction: Timeout while waiting for scout volume reconstruction result")
return
self.startStopScoutScanButton.setIcon(self.recordIcon)
self.startStopScoutScanButton.setText(" Scout Scan\n Start Recording")
self.startStopScoutScanButton.setEnabled(True)
if command.GetStatus() != command.CommandSuccess:
logging.debug("Scout Volume Reconstruction: " + command.GetResponseMessage())
return
self.executeCommandDelayed(self.onScoutVolumeReconstructedFinalize)
def onScoutVolumeReconstructedFinalize(self):
# Create and initialize ROI after scout scan because low resolution scout scan is used to set
# a smaller ROI for the live high resolution reconstruction
self.roiNode = self.logic.onRoiInitialization(self.SCOUT_VOLUME_NODE_NAME, self.roiNode)
self.roiOrigin, self.roiExtent = self.logic.updateVolumeOriginAndExtentFromROI(self.LIVE_OUTPUT_VOLUME_SPACING,
self.roiNode)
scoutScanVolumeNode = self.getScoutVolumeNode()
applicationLogic = slicer.app.applicationLogic()
applicationLogic.FitSliceToAll()
self.guideletParent.showVolumeRendering(scoutScanVolumeNode)
def onSnapshotAcquired(self, command, q):
self.printCommandResponse(command,q)
if not self.startStopLiveReconstructionButton.isChecked():
# live volume reconstruction is not active
return
self.executeCommandDelayed(self.onSnapshotAcquiredFinalize)
def onSnapshotAcquiredFinalize(self):
self.guideletParent.showVolumeRendering(self.getLiveVolumeRecNode())
self.snapshotTimer.start(self.SNAPSHOT_INTERVAL*1000)
def onVolumeLiveReconstructed(self, command, q):
self.printCommandResponse(command,q)
if command.GetStatus() == command.CommandExpired:
logging.fatal("LIVE Volume Reconstruction: Failed to stop volume reconstruction")
return
if command.GetStatus() != command.CommandSuccess:
logging.debug("LIVE Volume Reconstruction " + command.GetResponseMessage())
return
self.executeCommandDelayed(self.getLiveVolumeRecNode)
def onVolumeLiveReconstructedFinalize(self):
self.guideletParent.showVolumeRendering(self.getLiveVolumeRecNode())
def __init__(self, parent):
QComboBox.__init__(self, parent, "comboboxlista")
WidgetLista.__init__(self)
