def updateData(self, values11, values21, offset, segment_size=101):
# Update the data from (i*101) to (i+1)*101
logger.debug(
"Calculating data and inserting in existing data at offset %d",
offset)
for i in range(len(values11)):
re, im = values11[i]
re21, im21 = values21[i]
freq = self.data11[offset * segment_size + i].freq
rawData11 = Datapoint(freq, re, im)
rawData21 = Datapoint(freq, re21, im21)
# TODO: Use applyCalibration instead
if self.app.calibration.isCalculated:
re, im = self.app.calibration.correct11(re, im, freq)
if self.app.calibration.isValid2Port():
re21, im21 = self.app.calibration.correct21(
re21, im21, freq)
self.data11[offset * segment_size + i] = Datapoint(freq, re, im)
self.data21[offset * segment_size + i] = Datapoint(
freq, re21, im21)
self.rawData11[offset * segment_size + i] = rawData11
self.rawData21[offset * segment_size + i] = rawData21
logger.debug("Saving data to application (%d and %d points)",
len(self.data11), len(self.data21))
self.app.saveData(self.data11, self.data21)
logger.debug("Sending \"updated\" signal")
self.signals.updated.emit()
def setUp(self):
self.dp = Datapoint(100000, 0.1091, 0.3118)
self.dp0 = Datapoint(100000, 0, 0)
self.dp50 = Datapoint(100000, 1, 0)
self.dp75 = Datapoint(100000, 0.2, 0)
self.dp_im50 = Datapoint(100000, 0, 1)
self.dp_ill = Datapoint(100000, 1.1, 0)
def updateData(self, frequencies, values11, values21, index):
# Update the data from (i*101) to (i+1)*101
logger.debug(
"Calculating data and inserting in existing data at index %d",
index)
offset = self.sweep.points * index
v11 = values11[:]
v21 = values21[:]
raw_data11 = []
raw_data21 = []
for freq in frequencies:
real11, imag11 = v11.pop(0)
real21, imag21 = v21.pop(0)
raw_data11.append(Datapoint(freq, real11, imag11))
raw_data21.append(Datapoint(freq, real21, imag21))
data11, data21 = self.applyCalibration(raw_data11, raw_data21)
logger.debug("update Freqs: %s, Offset: %s", len(frequencies), offset)
for i in range(len(frequencies)):
self.data11[offset + i] = data11[i]
self.data21[offset + i] = data21[i]
self.rawData11[offset + i] = raw_data11[i]
self.rawData21[offset + i] = raw_data21[i]
logger.debug("Saving data to application (%d and %d points)",
len(self.data11), len(self.data21))
self.app.saveData(self.data11, self.data21)
logger.debug('Sending "updated" signal')
# self.signals.updated.emit()
self.updated = 1
def applyCalibration(self, raw_data11: List[Datapoint], raw_data21: List[Datapoint]) ->\
(List[Datapoint], List[Datapoint]):
if self.offsetDelay != 0:
tmp = []
for d in raw_data11:
tmp.append(Calibration.correctDelay11(d, self.offsetDelay))
raw_data11 = tmp
tmp = []
for d in raw_data21:
tmp.append(Calibration.correctDelay21(d, self.offsetDelay))
raw_data21 = tmp
if not self.app.calibration.isCalculated:
return raw_data11, raw_data21
data11: List[Datapoint] = []
data21: List[Datapoint] = []
if self.app.calibration.isValid1Port():
for d in raw_data11:
re, im = self.app.calibration.correct11(d.re, d.im, d.freq)
data11.append(Datapoint(d.freq, re, im))
else:
data11 = raw_data11
if self.app.calibration.isValid2Port():
for d in raw_data21:
re, im = self.app.calibration.correct21(d.re, d.im, d.freq)
data21.append(Datapoint(d.freq, re, im))
else:
data21 = raw_data21
return data11, data21
def init_data(self):
self.data11 = []
self.data21 = []
self.rawData11 = []
self.rawData21 = []
for freq in self.sweep.get_frequencies():
self.data11.append(Datapoint(freq, 0.0, 0.0))
self.data21.append(Datapoint(freq, 0.0, 0.0))
self.rawData11.append(Datapoint(freq, 0.0, 0.0))
self.rawData21.append(Datapoint(freq, 0.0, 0.0))
logger.debug("Init data length: %s", len(self.data11))
def test_cor_att_data(self):
dp1 = [
Datapoint(100000, 0.1091, 0.3118),
Datapoint(100001, 0.1091, 0.3124),
Datapoint(100002, 0.1091, 0.3130),
]
dp2 = corr_att_data(dp1, 10)
self.assertEqual(dp2[0].gain - dp1[0].gain, 10)
self.assertEqual(len(dp1), len(dp2))
# ignore negative attenuation
dp3 = corr_att_data(dp1, -10)
self.assertEqual(dp1, dp3)
def _append_line_data(self, freq: int, data: list):
data_list = iter(self.sdata)
vals = iter(data)
for v in vals:
if self.opts.format == "ri":
next(data_list).append(Datapoint(freq, float(v), float(next(vals))))
if self.opts.format == "ma":
z = cmath.rect(float(v), math.radians(float(next(vals))))
next(data_list).append(Datapoint(freq, z.real, z.imag))
if self.opts.format == "db":
z = cmath.rect(math.exp(float(v) / 20), math.radians(float(next(vals))))
next(data_list).append(Datapoint(freq, z.real, z.imag))
def correct21(self, dp: Datapoint):
i = self.interp
try:
s21 = (dp.z - i["e30"](dp.freq)) / i["e10e32"](dp.freq)
return Datapoint(dp.freq, s21.real, s21.imag)
except ValueError:
# TODO: implement warn message in gui
logger.info("Data outside calibration")
nearest = sorted(self.dataset.frequencies(),
key=lambda k: abs(dp.freq - k))[0]
ds = self.dataset.get(nearest)
s21 = (dp.z - ds["e30"]) / ds["e10e32"]
return Datapoint(dp.freq, s21.real, s21.imag)
class TestRFToolsDatapoint(unittest.TestCase):
def setUp(self):
self.dp = Datapoint(100000, 0.1091, 0.3118)
self.dp0 = Datapoint(100000, 0, 0)
self.dp50 = Datapoint(100000, 1, 0)
self.dp75 = Datapoint(100000, 0.2, 0)
self.dp_im50 = Datapoint(100000, 0, 1)
def test_properties(self):
self.assertEqual(self.dp.z, complex(0.1091, 0.3118))
self.assertAlmostEqual(self.dp.phase, 1.23420722)
self.assertEqual(self.dp0.gain, -math.inf)
self.assertAlmostEqual(self.dp.gain, -9.6208748)
self.assertEqual(self.dp50.vswr, 1.0)
self.assertAlmostEqual(self.dp.vswr, 1.9865736)
self.assertAlmostEqual(self.dp.impedance(),
complex(49.997525, 34.9974501))
self.assertAlmostEqual(self.dp.impedance(75),
complex(74.99628755, 52.49617517))
self.assertEqual(self.dp0.qFactor(), 0.0)
self.assertEqual(self.dp75.qFactor(), 0.0)
self.assertEqual(self.dp_im50.qFactor(), -1.0)
self.assertAlmostEqual(self.dp.qFactor(), 0.6999837)
self.assertAlmostEqual(self.dp.capacitiveEquivalent(), -4.54761539e-08)
self.assertAlmostEqual(self.dp.inductiveEquivalent(), 5.57001e-05)
def exportFile(self, filename: str, data: List[List[Datapoint]]):
ts = Touchstone(filename)
i = 0
ts.sdata[0] = data[0]
ts.sdata[1] = data[1]
for dp in data[0]:
ts.sdata[2].append(Datapoint(dp.freq, 0, 0))
ts.sdata[3].append(Datapoint(dp.freq, 0, 0))
try:
ts.save(4)
except IOError as e:
logger.exception("Error during file export: %s", e)
return
def test_setter(self):
ts = Touchstone("")
dp_list = [Datapoint(1, 0.0, 0.0), Datapoint(3, 1.0, 1.0)]
ts.s11data = dp_list[:]
ts.s21data = dp_list[:]
ts.s12data = dp_list[:]
ts.s22data = dp_list[:]
self.assertEqual(ts.s11data, dp_list)
self.assertEqual(ts.s21data, dp_list)
self.assertEqual(ts.s12data, dp_list)
self.assertEqual(ts.s22data, dp_list)
self.assertEqual(ts.min_freq(), 1)
self.assertEqual(ts.max_freq(), 3)
ts.gen_interpolation()
self.assertEqual(ts.s_freq("11", 2), Datapoint(2, 0.5, 0.5))
def correct11(self, dp: Datapoint):
i = self.interp
try:
s11 = (dp.z - i["e00"](dp.freq)) / (
(dp.z * i["e11"](dp.freq)) - i["delta_e"](dp.freq))
return Datapoint(dp.freq, s11.real, s11.imag)
except ValueError:
# TODO: implement warn message in gui
logger.info("Data outside calibration")
nearest = sorted(self.dataset.frequencies(),
key=lambda k: abs(dp.freq - k))[0]
ds = self.dataset.get(nearest)
s11 = (dp.z - ds["e00"]) / (
(dp.z * ds["e11"]) - ds["delta_e"])
return Datapoint(dp.freq, s11.real, s11.imag)
def test_save(self):
ts = Touchstone("./test/data/valid.s2p")
self.assertEqual(ts.saves(), "# HZ S RI R 50\n")
ts.load()
lines = ts.saves().splitlines()
self.assertEqual(len(lines), 1021)
self.assertEqual(lines[0], "# HZ S RI R 50")
self.assertEqual(lines[1], '500000 -0.333238 0.000180018')
self.assertEqual(lines[-1], '900000000 -0.127646 0.31969')
lines = ts.saves(4).splitlines()
self.assertEqual(len(lines), 1021)
self.assertEqual(lines[0], "# HZ S RI R 50")
self.assertEqual(
lines[1], '500000 -0.333238 0.000180018 0.67478 -8.1951e-07'
' 0.67529 -8.20129e-07 -0.333238 0.000308078')
self.assertEqual(
lines[-1], '900000000 -0.127646 0.31969 0.596287 -0.503453'
' 0.599076 -0.50197 -0.122713 0.326965')
ts.filename = "./test/data/output.s2p"
ts.save(4)
os.remove(ts.filename)
ts.filename = ""
self.assertRaises(FileNotFoundError, ts.save)
ts.s11data[0] = Datapoint(100, 0.1, 0.1)
self.assertRaisesRegex(LookupError,
"Frequencies of sdata not correlated", ts.saves,
4)
def getYPosition(self, d: Datapoint) -> int:
try:
return (self.topMargin + round(
(self.maxValue - d.capacitiveEquivalent()) / self.span *
self.dim.height))
except ValueError:
return self.topMargin
def test_load(self):
ts = Touchstone("./test/data/valid.s1p")
ts.load()
self.assertEqual(str(ts.opts), "# HZ S RI R 50")
self.assertEqual(len(ts.s11data), 1010)
self.assertEqual(len(ts.s21data), 0)
self.assertEqual(ts.r, 50)
ts = Touchstone("./test/data/valid.s2p")
ts.load()
ts.gen_interpolation()
self.assertEqual(str(ts.opts), "# HZ S RI R 50")
self.assertEqual(len(ts.s11data), 1020)
self.assertEqual(len(ts.s21data), 1020)
self.assertEqual(len(ts.s12data), 1020)
self.assertEqual(len(ts.s22data), 1020)
self.assertIn("! Vector Network Analyzer VNA R2", ts.comments)
self.assertEqual(ts.min_freq(), 500000)
self.assertEqual(ts.max_freq(), 900000000)
self.assertEqual(ts.s_freq("11", 1),
Datapoint(1, -3.33238E-001, 1.80018E-004))
self.assertEqual(
ts.s_freq("11", 750000),
Datapoint(750000, -0.3331754099382822, 0.00032433255669243524))
ts = Touchstone("./test/data/ma.s2p")
ts.load()
self.assertEqual(str(ts.opts), "# MHZ S MA R 50")
ts = Touchstone("./test/data/db.s2p")
ts.load()
self.assertEqual(str(ts.opts), "# HZ S DB R 50")
ts = Touchstone("./test/data/broken_pair.s2p")
with self.assertLogs(level=logging.ERROR) as cm:
ts.load()
self.assertRegex(cm.output[0], "Data values aren't pairs")
ts = Touchstone("./test/data/missing_pair.s2p")
with self.assertLogs(level=logging.ERROR) as cm:
ts.load()
self.assertRegex(cm.output[0], "Inconsistent number")
ts = Touchstone("./test/data/nonexistent.s2p")
with self.assertLogs(level=logging.ERROR) as cm:
ts.load()
self.assertRegex(cm.output[0], "No such file or directory")
def saveData(self, frequencies, values11, values21):
rawData11 = []
rawData21 = []
logger.debug("Calculating data including corrections")
for i in range(len(values11)):
re, im = values11[i]
re21, im21 = values21[i]
freq = frequencies[i]
rawData11 += [Datapoint(freq, re, im)]
rawData21 += [Datapoint(freq, re21, im21)]
self.data11, self.data21 = self.applyCalibration(rawData11, rawData21)
self.rawData11 = rawData11
self.rawData21 = rawData21
logger.debug("Saving data to application (%d and %d points)", len(self.data11), len(self.data21))
self.app.saveData(self.data11, self.data21)
logger.debug("Sending \"updated\" signal")
self.signals.updated.emit()
def drawBands(self, qp, fstart, fstop):
qp.setBrush(self.bands.color)
qp.setPen(QtGui.QColor(128, 128, 128, 0)) # Don't outline the bands
for _, start, end in self.bands.bands:
try:
start = int(start)
end = int(end)
except ValueError:
continue
# don't draw if either band not in chart or completely in band
if start < fstart < fstop < end or end < fstart or start > fstop:
continue
x_start = max(self.leftMargin + 1,
self.getXPosition(Datapoint(start, 0, 0)))
x_stop = min(self.leftMargin + self.chartWidth,
self.getXPosition(Datapoint(end, 0, 0)))
qp.drawRect(x_start, self.topMargin, x_stop - x_start,
self.chartHeight)
class TestRFToolsDatapoint(unittest.TestCase):
def setUp(self):
self.dp = Datapoint(100000, 0.1091, 0.3118)
self.dp0 = Datapoint(100000, 0, 0)
self.dp50 = Datapoint(100000, 1, 0)
def test_properties(self):
self.assertEqual(self.dp.z, complex(0.1091, 0.3118))
self.assertAlmostEqual(self.dp.phase, 1.23420722)
self.assertEqual(self.dp0.gain, 0.0)
self.assertAlmostEqual(self.dp.gain, -9.6208748)
self.assertEqual(self.dp50.vswr, 1.0)
self.assertAlmostEqual(self.dp.vswr, 1.9865736)
self.assertAlmostEqual(self.dp.impedance(),
complex(49.997525, 34.9974501))
self.assertAlmostEqual(self.dp.impedance(75),
complex(74.99628755, 52.49617517))
self.assertEqual(self.dp0.qFactor(), 0.0)
self.assertAlmostEqual(self.dp.qFactor(), 0.6999837)
def updateData(self, values11, values21, offset, segment_size=101):
# Update the data from (i*101) to (i+1)*101
logger.debug("Calculating data and inserting in existing data at offset %d", offset)
for i, val11 in enumerate(values11):
re, im = val11
re21, im21 = values21[i]
freq = self.data11[offset * segment_size + i].freq
raw_data11 = Datapoint(freq, re, im)
raw_data21 = Datapoint(freq, re21, im21)
data11, data21 = self.applyCalibration([raw_data11], [raw_data21])
self.data11[offset * segment_size + i] = data11[0]
self.data21[offset * segment_size + i] = data21[0]
self.rawData11[offset * segment_size + i] = raw_data11
self.rawData21[offset * segment_size + i] = raw_data21
logger.debug("Saving data to application (%d and %d points)",
len(self.data11), len(self.data21))
self.app.saveData(self.data11, self.data21)
logger.debug("Sending \"updated\" signal")
self.signals.updated.emit()
def exportFile(self, nr_params: int = 1):
if len(self.app.data.s11) == 0:
QtWidgets.QMessageBox.warning(self, "No data to save",
"There is no data to save.")
return
if nr_params > 2 and len(self.app.data.s21) == 0:
QtWidgets.QMessageBox.warning(self, "No S21 data to save",
"There is no S21 data to save.")
return
filedialog = QtWidgets.QFileDialog(self)
if nr_params == 1:
filedialog.setDefaultSuffix("s1p")
filedialog.setNameFilter(
"Touchstone 1-Port Files (*.s1p);;All files (*.*)")
else:
filedialog.setDefaultSuffix("s2p")
filedialog.setNameFilter(
"Touchstone 2-Port Files (*.s2p);;All files (*.*)")
filedialog.setAcceptMode(QtWidgets.QFileDialog.AcceptSave)
selected = filedialog.exec()
if not selected:
return
filename = filedialog.selectedFiles()[0]
if filename == "":
logger.debug("No file name selected.")
return
ts = Touchstone(filename)
ts.sdata[0] = self.app.data.s11
if nr_params > 1:
ts.sdata[1] = self.app.data.s21
for dp in self.app.data.s11:
ts.sdata[2].append(Datapoint(dp.freq, 0, 0))
ts.sdata[3].append(Datapoint(dp.freq, 0, 0))
try:
ts.save(nr_params)
except IOError as e:
logger.exception("Error during file export: %s", e)
return
def getImYPosition(self, d: Datapoint) -> int:
im = d.impedance().imag
im = im * 10e6 / d.freq
if self.logarithmicY:
min_val = self.max - self.span
if self.max > 0 and min_val > 0 and im > 0:
span = math.log(self.max) - math.log(min_val)
else:
return -1
return self.topMargin + round(
(math.log(self.max) - math.log(im)) / span * self.chartHeight)
return self.topMargin + round(
(self.max - im) / self.span * self.chartHeight)
def saveData(self, frequencies, values11, values21):
logger.debug("Freqs: %d, values11: %d, values21: %d", len(frequencies),
len(values11), len(values21))
v11 = values11[:]
v21 = values21[:]
raw_data11 = []
raw_data21 = []
logger.debug("Calculating data including corrections")
for freq in frequencies:
real11, imag11 = v11.pop(0)
real21, imag21 = v21.pop(0)
raw_data11.append(Datapoint(freq, real11, imag11))
raw_data21.append(Datapoint(freq, real21, imag21))
self.rawData11 = raw_data11
self.rawData21 = raw_data21
self.data11, self.data21 = self.applyCalibration(
raw_data11, raw_data21)
logger.debug("Saving data to application (%d and %d points)",
len(self.data11), len(self.data21))
self.app.saveData(self.data11, self.data21)
logger.debug("Sending \"updated\" signal")
self.signals.updated.emit()
def getReYPosition(self, d: Datapoint) -> int:
re = d.impedance().real
re = re * 10e6 / d.freq
if self.logarithmicY:
min_val = self.max - self.span
if self.max > 0 and min_val > 0 and re > 0:
span = math.log(self.max) - math.log(min_val)
else:
return -1
return self.topMargin + round(
(math.log(self.max) - math.log(re)) / span * self.chartHeight)
return self.topMargin + round(
(self.max - re) / self.span * self.chartHeight)
def drawBands(self, qp, fstart, fstop):
qp.setBrush(self.bands.color)
qp.setPen(QtGui.QColor(128, 128, 128, 0)) # Don't outline the bands
for (_, start, end) in self.bands.bands:
if fstart < start < fstop and fstart < end < fstop:
# The band is entirely within the chart
x_start = self.getXPosition(Datapoint(start, 0, 0))
x_end = self.getXPosition(Datapoint(end, 0, 0))
qp.drawRect(x_start, self.topMargin, x_end - x_start,
self.chartHeight)
elif fstart < start < fstop:
# Only the start of the band is within the chart
x_start = self.getXPosition(Datapoint(start, 0, 0))
qp.drawRect(x_start, self.topMargin,
self.leftMargin + self.chartWidth - x_start,
self.chartHeight)
elif fstart < end < fstop:
# Only the end of the band is within the chart
x_end = self.getXPosition(Datapoint(end, 0, 0))
qp.drawRect(self.leftMargin + 1, self.topMargin,
x_end - (self.leftMargin + 1), self.chartHeight)
elif start < fstart < fstop < end:
# All the chart is in a band, we won't show it(?)
pass
def applyCalibration(self, raw_data11: List[Datapoint], raw_data21: List[Datapoint]) ->\
(List[Datapoint], List[Datapoint]):
if not self.app.calibration.isCalculated:
return raw_data11, raw_data21
data11: List[Datapoint] = []
data21: List[Datapoint] = []
if self.app.calibration.isValid1Port():
logger.debug("Applying S11 calibration.")
for d in raw_data11:
re, im = self.app.calibration.correct11(d.re, d.im, d.freq)
data11.append(Datapoint(d.freq, re, im))
else:
data11 = raw_data11
if self.app.calibration.isValid2Port():
logger.debug("Applying S21 calibration.")
for d in raw_data21:
re, im = self.app.calibration.correct21(d.re, d.im, d.freq)
data21.append(Datapoint(d.freq, re, im))
else:
data21 = raw_data21
return data11, data21
def test_groupDelay(self):
dpoints = [
Datapoint(100000, 0.1091, 0.3118),
Datapoint(100001, 0.1091, 0.3124),
Datapoint(100002, 0.1091, 0.3130),
]
dpoints0 = [
Datapoint(100000, 0.1091, 0.3124),
Datapoint(100000, 0.1091, 0.3124),
Datapoint(100000, 0.1091, 0.3124),
]
self.assertAlmostEqual(groupDelay(dpoints, 1), -9.514e-5)
self.assertEqual(groupDelay(dpoints0, 1), 0.0)
def load(self, filename):
self.source = os.path.basename(filename)
self.dataset = CalDataSet()
self.notes = []
parsed_header = False
with open(filename) as calfile:
for i, line in enumerate(calfile):
line = line.strip()
if line.startswith("!"):
note = line[2:]
self.notes.append(note)
continue
if line.startswith("#"):
if not parsed_header:
# Check that this is a valid header
if line == (
"# Hz ShortR ShortI OpenR OpenI LoadR LoadI"
" ThroughR ThroughI IsolationR IsolationI"):
parsed_header = True
continue
if not parsed_header:
logger.warning(
"Warning: Read line without having read header: %s",
line)
continue
m = RXP_CAL_LINE.search(line)
if not m:
logger.warning("Illegal data in cal file. Line %i", i)
cal = m.groupdict()
if cal["throughr"]:
nr_cals = 5
else:
nr_cals = 3
for name in Calibration.CAL_NAMES[:nr_cals]:
self.dataset.insert(
name,
Datapoint(int(cal["freq"]),
float(cal[f"{name}r"]),
float(cal[f"{name}i"])))
def getYPosition(self, d: Datapoint) -> int:
return (self.topMargin + round(
(self.maxValue - d.inductiveEquivalent()) / self.span *
self.chartHeight))
def magnitude(p: Datapoint) -> float:
return abs(p.shuntImpedance())
class MarkerSettingsWindow(QtWidgets.QWidget):
exampleData11 = [
Datapoint(123000000, 0.89, -0.11),
Datapoint(123500000, 0.9, -0.1),
Datapoint(124000000, 0.91, -0.95)
]
exampleData21 = [
Datapoint(123000000, -0.25, 0.49),
Datapoint(123456000, -0.3, 0.5),
Datapoint(124000000, -0.2, 0.5)
]
def __init__(self, app: QtWidgets.QWidget):
super().__init__()
self.app = app
self.setWindowTitle("Marker settings")
self.setWindowIcon(self.app.icon)
QtWidgets.QShortcut(QtCore.Qt.Key_Escape, self, self.cancelButtonClick)
self.exampleMarker = Marker("Example marker")
layout = QtWidgets.QVBoxLayout()
self.setLayout(layout)
settings_group_box = QtWidgets.QGroupBox("Settings")
settings_group_box_layout = QtWidgets.QFormLayout(settings_group_box)
self.checkboxColouredMarker = QtWidgets.QCheckBox(
"Colored marker name")
self.checkboxColouredMarker.setChecked(
self.app.settings.value("ColoredMarkerNames", True, bool))
self.checkboxColouredMarker.stateChanged.connect(self.updateMarker)
settings_group_box_layout.addRow(self.checkboxColouredMarker)
fields_group_box = QtWidgets.QGroupBox("Displayed data")
fields_group_box_layout = QtWidgets.QFormLayout(fields_group_box)
self.savedFieldSelection = self.app.settings.value(
"MarkerFields", defaultValue=default_label_ids())
if self.savedFieldSelection == "":
self.savedFieldSelection = []
self.currentFieldSelection = self.savedFieldSelection[:]
self.active_labels_view = QtWidgets.QListView()
self.update_displayed_data_form()
fields_group_box_layout.addRow(self.active_labels_view)
layout.addWidget(settings_group_box)
layout.addWidget(fields_group_box)
layout.addWidget(self.exampleMarker.getGroupBox())
btn_layout = QtWidgets.QHBoxLayout()
layout.addLayout(btn_layout)
btn_ok = QtWidgets.QPushButton("OK")
btn_apply = QtWidgets.QPushButton("Apply")
btn_default = QtWidgets.QPushButton("Defaults")
btn_cancel = QtWidgets.QPushButton("Cancel")
btn_ok.clicked.connect(self.okButtonClick)
btn_apply.clicked.connect(self.applyButtonClick)
btn_default.clicked.connect(self.defaultButtonClick)
btn_cancel.clicked.connect(self.cancelButtonClick)
btn_layout.addWidget(btn_ok)
btn_layout.addWidget(btn_apply)
btn_layout.addWidget(btn_default)
btn_layout.addWidget(btn_cancel)
self.updateMarker()
for m in self.app.markers:
m.setFieldSelection(self.currentFieldSelection)
m.setColoredText(self.checkboxColouredMarker.isChecked())
def updateMarker(self):
self.exampleMarker.setFrequency(123456000)
self.exampleMarker.setColoredText(
self.checkboxColouredMarker.isChecked())
self.exampleMarker.setFieldSelection(self.currentFieldSelection)
self.exampleMarker.findLocation(self.exampleData11)
self.exampleMarker.resetLabels()
self.exampleMarker.updateLabels(self.exampleData11, self.exampleData21)
def updateField(self, field: QtGui.QStandardItem):
if field.checkState() == QtCore.Qt.Checked:
if not field.data() in self.currentFieldSelection:
self.currentFieldSelection = []
for i in range(self.model.rowCount()):
field = self.model.item(i, 0)
if field.checkState() == QtCore.Qt.Checked:
self.currentFieldSelection.append(field.data())
else:
if field.data() in self.currentFieldSelection:
self.currentFieldSelection.remove(field.data())
self.updateMarker()
def applyButtonClick(self):
self.savedFieldSelection = self.currentFieldSelection[:]
self.app.settings.setValue("MarkerFields", self.savedFieldSelection)
self.app.settings.setValue("ColoredMarkerNames",
self.checkboxColouredMarker.isChecked())
for m in self.app.markers:
m.setFieldSelection(self.savedFieldSelection)
m.setColoredText(self.checkboxColouredMarker.isChecked())
def okButtonClick(self):
self.applyButtonClick()
self.close()
def cancelButtonClick(self):
self.currentFieldSelection = self.savedFieldSelection[:]
self.update_displayed_data_form()
self.updateMarker()
self.close()
def defaultButtonClick(self):
self.currentFieldSelection = default_label_ids()
self.update_displayed_data_form()
self.updateMarker()
def update_displayed_data_form(self):
self.model = QtGui.QStandardItemModel()
for label in TYPES:
item = QtGui.QStandardItem(label.description)
item.setData(label.label_id)
item.setCheckable(True)
item.setEditable(False)
if label.label_id in self.currentFieldSelection:
item.setCheckState(QtCore.Qt.Checked)
self.model.appendRow(item)
self.active_labels_view.setModel(self.model)
self.model.itemChanged.connect(self.updateField)
