def test_getModel(qtbot):
table_view = CalibrationTableView()
table_model = CalibrationTableModel()
qtbot.addWidget(table_view)
table_view.setModel(table_model)
assert table_model == table_view.getModel()
def test_addRemoveRows(qtbot, open_window):
table_model = CalibrationTableModel()
table_view = open_window(CalibrationTableView)
table_view.setModel(table_model)
starting_count = table_model.rowCount()
#Find a QRect of a row
cell_rect = table_view.visualRect(table_model.index(1,1,QtCore.QModelIndex()))
#Add One After
table_view.setSelection(cell_rect, QtCore.QItemSelectionModel.Select)
table_view.addRowAfterSelected()
assert (starting_count+1) == table_model.rowCount()
qtbot.wait(TestingFlags.TEST_WAIT_SHORT)
#Remove One
table_view.setSelection(cell_rect, QtCore.QItemSelectionModel.Select)
table_view.removeSelectedRow()
assert (starting_count) == table_model.rowCount()
qtbot.wait(TestingFlags.TEST_WAIT_SHORT)
#Add One Before
table_view.setSelection(cell_rect, QtCore.QItemSelectionModel.Select)
table_view.addRowBeforeSelected()
assert (starting_count+1) == table_model.rowCount()
qtbot.wait(TestingFlags.TEST_WAIT_SHORT)
def __init__(self, parent=None):
super().__init__(parent)
self._name = 'Analog_Input_Node'
self._hal_val = 0
self._val = 0
self._units = ''
self._display_digits = defaults.A_DISPLAY_DIGITS
self._display_scientific = False
self._calibration_table_model = CalibrationTableModel()
self._calibration_table_model.dataChanged.connect(
self.updateScaleFactor)
self._calibration_table_model.modelReset.connect(
self.updateScaleFactor)
self._xp = [0, 0]
self._yp = [0, 0]
def test_contextMenuEvent(qtbot, open_window):
table_model = CalibrationTableModel()
table_view = open_window(CalibrationTableView)
table_view.setModel(table_model)
if TestingFlags.ENABLE_MANUAL_TESTING:
message = QtWidgets.QMessageBox()
message.setText("Test the right click menu on the table.\nHal values must be increasing.\nGui values can be increasing or decreasing")
message.exec_()
qtbot.stopForInteraction()
def test_setDataArray(good_data_arrays, bad_data_arrays):
table_model = CalibrationTableModel()
for good_data in good_data_arrays:
table_model.setDataArray(good_data)
assert good_data == table_model.dataArray()
for bad_data in bad_data_arrays:
with pytest.raises(Exception) as e_info:
table_model.setDataArray(bad_data)
def test_headerData(good_data_arrays):
table_model = CalibrationTableModel()
for good_data in good_data_arrays:
table_model.setDataArray(good_data)
assert "HAL Value" == table_model.headerData(0,QtCore.Qt.Horizontal,QtCore.Qt.DisplayRole)
assert "GUI Value" == table_model.headerData(1,QtCore.Qt.Horizontal,QtCore.Qt.DisplayRole)
assert "0" == table_model.headerData(0,QtCore.Qt.Vertical,QtCore.Qt.DisplayRole)
def test_AnalogInputNode_setData():
node = AnalogInputNode()
cal = [['hal_value', 'gui_value'], [0.0, 0.0], [10.0, 500.0]]
node.calibrationTableData = cal
node.setData(col.HAL_VALUE, 1.5)
node.setData(col.VALUE, "can't set this")
node.setData(col.UNITS, 'mTorr')
node.setData(col.DISPLAY_DIGITS, 5)
node.setData(col.DISPLAY_SCIENTIFIC, True)
node.setData(col.CALIBRATION_TABLE_MODEL, "can't set this")
assert node.data(col.HAL_VALUE) == 1.5
assert node.data(col.VALUE) == 75
assert node.data(col.UNITS) == 'mTorr'
assert node.data(col.DISPLAY_DIGITS) == 5
assert node.data(col.DISPLAY_SCIENTIFIC) == True
assert type(node.data(col.CALIBRATION_TABLE_MODEL)) == type(
CalibrationTableModel())
def test_dataArray(good_data_arrays):
table_model = CalibrationTableModel()
for good_data in good_data_arrays:
table_model.setDataArray(good_data)
returned_array = table_model.dataArray()
returned_array_copy = copy.deepcopy(returned_array)
for i, row in enumerate(returned_array):
for j, val in enumerate(row):
returned_array[i][j] = None
assert returned_array_copy == table_model.dataArray()
def test_flags(good_data_arrays):
table_model = CalibrationTableModel()
hal_col = table_model.halValueColumn()
gui_col = table_model.halValueColumn()
for good_data in good_data_arrays:
table_model.setDataArray(good_data)
main_data = good_data[1:]
for i, row in enumerate(main_data):
hal_flags = table_model.flags(table_model.index(i, hal_col, QtCore.QModelIndex()))
gui_flags = table_model.flags(table_model.index(i, gui_col, QtCore.QModelIndex()))
assert hal_flags == QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable
assert gui_flags == QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable
def test_rowCount(good_data_arrays):
table_model = CalibrationTableModel()
for good_data in good_data_arrays:
table_model.setDataArray(good_data)
assert table_model.rowCount() == len(good_data)-1
def test_setData_decreasing():
tbl_1 = [['hal_value', 'gui_value'],
[ 0.0, 1000],
[ 2.5, 900],
[ 5.0, 300],
[ 7.5, 0],
[ 10.0, -100]]
table_model = CalibrationTableModel()
table_model.setDataArray(tbl_1)
gui_col = 1
#These should succeed at changing the data
index = table_model.index(0,gui_col, QtCore.QModelIndex())
table_model.setData(index, 1200, QtCore.Qt.EditRole)
assert 1200 == table_model.data(index, QtCore.Qt.DisplayRole)
index = table_model.index(4,gui_col, QtCore.QModelIndex())
table_model.setData(index, -101, QtCore.Qt.EditRole)
assert -101 == table_model.data(index, QtCore.Qt.DisplayRole)
#This should fail
index = table_model.index(4,gui_col, QtCore.QModelIndex())
with pytest.raises(Exception) as e_info:
table_model.setData(index, 0, QtCore.Qt.EditRole)
def test_setData_increasing():
tbl_1 = [['hal_value', 'gui_value'],
[ 0, 0.00],
[ 10, 0.60],
[ 50, 3.10],
[ 100, 9.00],
[ 160, 24.00]]
table_model = CalibrationTableModel()
table_model.setDataArray(tbl_1)
#These should succeed at changing the data
index = table_model.index(0,0, QtCore.QModelIndex())
table_model.setData(index, -12.3, QtCore.Qt.EditRole)
assert -12.3 == table_model.data(index, QtCore.Qt.DisplayRole)
index = table_model.index(0,1, QtCore.QModelIndex())
table_model.setData(index, -1., QtCore.Qt.EditRole)
assert -1. == table_model.data(index, QtCore.Qt.DisplayRole)
#These should fail at changing the data
index = table_model.index(0,0, QtCore.QModelIndex())
with pytest.raises(Exception) as e_info:
table_model.setData(index, 3999, QtCore.Qt.EditRole)
index = table_model.index(0,1, QtCore.QModelIndex())
with pytest.raises(Exception) as e_info:
table_model.setData(index, 16000, QtCore.Qt.EditRole)
index = table_model.index(2,0, QtCore.QModelIndex())
with pytest.raises(Exception) as e_info:
table_model.setData(index, 'cat', QtCore.Qt.EditRole)
#These should work
index = table_model.index(2,0, QtCore.QModelIndex())
table_model.setData(index, 10.01, QtCore.Qt.EditRole)
assert 10.01 == table_model.data(index, QtCore.Qt.DisplayRole)
index = table_model.index(2,1, QtCore.QModelIndex())
table_model.setData(index, 8.999, QtCore.Qt.EditRole)
assert 8.999 == table_model.data(index, QtCore.Qt.DisplayRole)
def test_AnalogInputNode_calibrationTableModel():
node = AnalogInputNode()
assert type(node.calibrationTableModel()) == type(CalibrationTableModel())
def test_setData_increasing_to_decreasing():
tbl_1 = [['hal_value', 'gui_value'],
[ 0.0, 10],
[ 10.0, 100]]
table_model = CalibrationTableModel()
table_model.setDataArray(tbl_1)
gui_col = 1
#If there's just two rows we can change if it's increasing or decreasing
index = table_model.index(0,gui_col, QtCore.QModelIndex())
table_model.setData(index, 1200, QtCore.Qt.EditRole)
assert 1200 == table_model.data(index, QtCore.Qt.DisplayRole)
#If there's just two rows we can change if it's increasing or decreasing
index = table_model.index(1,gui_col, QtCore.QModelIndex())
table_model.setData(index, 12000, QtCore.Qt.EditRole)
assert 12000 == table_model.data(index, QtCore.Qt.DisplayRole)
def test_removeRows():
table_model = CalibrationTableModel()
tbl_1 = [['hal_value', 'gui_value'],
[ 0, 0.00],
[ 10, 0.63],
[ 50, 3.10],
[ 100, 9.66],
[ 255, 24.00]]
#Try removing 2 rows
number_to_remove = 2
row_index = 1
table_model.setDataArray(tbl_1)
table_model.removeRows(row_index,number_to_remove)
tbl_2 = [['hal_value', 'gui_value'],
[ 0, 0.00],
[ 100, 9.66],
[ 255, 24.00]]
assert tbl_2 == table_model.dataArray()
#Try removing 1 row
number_to_remove = 1
row_index = 0
table_model.removeRows(row_index,number_to_remove)
tbl_3 = [['hal_value', 'gui_value'],
[ 100, 9.66],
[ 255, 24.00]]
assert tbl_3 == table_model.dataArray()
#Try removing 1 row too many!
number_to_remove = 1
row_index = 0
table_model.removeRows(row_index,number_to_remove)
assert tbl_3 == table_model.dataArray()
def test_columnCount(good_data_arrays):
table_model = CalibrationTableModel()
for good_data in good_data_arrays:
table_model.setDataArray(good_data)
assert table_model.columnCount() == 2
def test_insertRows():
tbl_1 = [['hal_value', 'gui_value'],
[ 0, 0.00],
[ 10, 0.60],
[ 50, 3.10],
[ 100, 9.00],
[ 160, 24.00]]
table_model = CalibrationTableModel()
table_model.setDataArray(tbl_1)
#First try adding 1 row
number_to_add = 1
row_index = 1 #it's inserted above this index
tbl_2 = [['hal_value', 'gui_value'],
[ 0, 0.00],
[ 5, 0.30],
[ 10, 0.60],
[ 50, 3.10],
[ 100, 9.00],
[ 160, 24.00]]
table_model.insertRows(row_index,number_to_add)
assert tbl_2 == table_model.dataArray()
#Try adding 2 rows
number_to_add = 2
row_index = 5 #it's inserted above this index
tbl_3 = [['hal_value', 'gui_value'],
[ 0, 0.00],
[ 5, 0.30],
[ 10, 0.60],
[ 50, 3.10],
[ 100, 9.00],
[ 120, 14.0],
[ 140, 19.0],
[ 160, 24.00]]
table_model.insertRows(row_index,number_to_add)
assert tbl_3 == table_model.dataArray()
#Try adding 2 rows at beginning
number_to_add = 2
row_index = 0 #it's inserted above this index
tbl_4 = [['hal_value', 'gui_value'],
[ -10, -0.60], #row 0
[ -5, -0.30],
[ 0, 0.00],
[ 5, 0.30],
[ 10, 0.60],
[ 50, 3.10],
[ 100, 9.00],
[ 120, 14.0],
[ 140, 19.0],
[ 160, 24.00]] #row 9
table_model.insertRows(row_index,number_to_add)
assert tbl_4 == table_model.dataArray()
#Try adding 2 rows at the end
number_to_add = 2
row_index = 10 #it's inserted above this index
tbl_5 = [['hal_value', 'gui_value'],
[ -10, -0.60], #row 0
[ -5, -0.30],
[ 0, 0.00],
[ 5, 0.30],
[ 10, 0.60],
[ 50, 3.10],
[ 100, 9.00],
[ 120, 14.0],
[ 140, 19.0],
[ 160, 24.00],
[ 180, 29.00],
[ 200, 34.00]] #row 11
table_model.insertRows(row_index,number_to_add)
assert tbl_5 == table_model.dataArray()
class CalibrationTableView(QtWidgets.QTableView):
def __init__(self, parent=None):
super().__init__(parent)
self.menu_add_row_before = "Add Row Before"
self.menu_add_row_after = "Add Row After"
self.menu_remove_row = "Remove Row"
item_delegate = ValidatedDelegate()
self.setItemDelegate(item_delegate)
self.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
def setModel(self, value):
super(CalibrationTableView, self).setModel(value)
self.__setupGUI()
def getModel(self):
return self.model()
def addRowBeforeSelected(self):
if len(self.selectedIndexes()) == 1:
item = self.selectedIndexes()[0]
self.model().insertRows(item.row(), 1)
def addRowAfterSelected(self):
if len(self.selectedIndexes()) == 1:
item = self.selectedIndexes()[0]
self.model().insertRows(item.row()+1, 1)
def removeSelectedRow(self):
if len(self.selectedIndexes()) == 1:
item = self.selectedIndexes()[0]
self.model().removeRows(item.row(),1)
def contextMenuEvent(self, event):
if self.selectionModel().selection().indexes():
#Setup the menu
menu = QtWidgets.QMenu(self)
menu.addAction(self.menu_add_row_before)
menu.addAction(self.menu_add_row_after)
if self.model().rowCount() > 2:
menu.addAction(self.menu_remove_row)
action = menu.exec_(self.mapToGlobal(event.pos()))
if action is not None:
if action.text() == self.menu_add_row_before: self.addRowBeforeSelected()
elif action.text() == self.menu_add_row_after : self.addRowAfterSelected()
elif action.text() == self.menu_remove_row : self.removeSelectedRow()
def __setupGUI(self):
header = self.horizontalHeader()
header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)
font = QtGui.QFont("Helvetica", 14)
self.setFont(font)
#def reset(self):
# super(CalibrationTableView, self).reset()
# self.__setupGUI()
calibrationTableView = QtCore.pyqtProperty(type(CalibrationTableModel()), getModel, setModel)
class AnalogInputNode(HalNode):
'''
Represents an analog input (i.e. 0-10 VDC) for a device
- calibration_table_model : Calibration of analog signal to HAL numbers
- calibration_table_data : This property is used to load and save cal data
- display_digits : number of digits to display on default
- display_scientific : If true use scientific notation
'''
def __init__(self, parent=None):
super().__init__(parent)
self._name = 'Analog_Input_Node'
self._hal_val = 0
self._val = 0
self._units = ''
self._display_digits = defaults.A_DISPLAY_DIGITS
self._display_scientific = False
self._calibration_table_model = CalibrationTableModel()
self._calibration_table_model.dataChanged.connect(
self.updateScaleFactor)
self._calibration_table_model.modelReset.connect(
self.updateScaleFactor)
self._xp = [0, 0]
self._yp = [0, 0]
def typeInfo(self):
return typ.A_IN_NODE
def calibrationTableModel(self):
return self._calibration_table_model
def data(self, c):
r = super().data(c)
if c is col.HAL_VALUE: r = self._hal_val
elif c is col.VALUE: r = self.value()
elif c is col.UNITS: r = self.units
elif c is col.DISPLAY_DIGITS: r = self.displayDigits
elif c is col.DISPLAY_SCIENTIFIC: r = self.displayScientific
elif c is col.CALIBRATION_TABLE_MODEL:
r = self._calibration_table_model
return r
def setData(self, c, value):
super().setData(c, value)
if c is col.HAL_VALUE: self._hal_val = value
elif c is col.VALUE: pass
elif c is col.UNITS: self.units = value
elif c is col.DISPLAY_DIGITS: self.displayDigits = value
elif c is col.DISPLAY_SCIENTIFIC: self.displayScientific = value
def value(self):
return float(np.interp(self._hal_val, self._xp, self._yp))
def displayToHal(self, val):
return np.interp(val, self._yp, self._xp)
def updateScaleFactor(self):
try:
self._xp = self._calibration_table_model.halValues()
self._yp = self._calibration_table_model.guiValues()
except:
self._xp = [0, 10]
self._yp = [0, 10]
def halPins(self):
all_pins = HalNode.hal_pins #list of (name, type, dir)
sub_pins = [
item for item in all_pins if item[1] in ['s32', 'u32', 'float']
]
pins = [item[0] for item in sub_pins if item[2] == 'OUT']
pins.insert(0, '')
return enum(pins)
def units():
def fget(self):
return self._units
def fset(self, value):
self._units = str(value)
return locals()
units = property(**units())
def displayDigits():
def fget(self):
return self._display_digits
def fset(self, value):
self._display_digits = clamp(int(value), 0,
defaults.A_DISPLAY_DIGITS_MAX)
self.updateScaleFactor()
return locals()
displayDigits = property(**displayDigits())
def displayScientific():
def fget(self):
return self._display_scientific
def fset(self, value):
if value == True or value == 'True':
self._display_scientific = True
else:
self._display_scientific = False
return locals()
displayScientific = property(**displayScientific())
def calibrationTableData():
def fget(self):
return self.calibrationTableModel().dataArray()
def fset(self, value):
try:
self.calibrationTableModel().setDataArray(value)
self.updateScaleFactor()
except Exception as e:
MessageBox("Malformed calibration table data", e, value)
return locals()
calibrationTableData = property(**calibrationTableData())
