class CentralWidget(QSplitter):
def __init__(self, parent, settings, toolbar, start_freq, bandwidth,
numpts, dev):
QSplitter.__init__(self, parent)
self.setContentsMargins(10, 10, 10, 10)
self.setOrientation(Qt.Vertical)
self.curvewidget = CurveWidget(self)
self.item = {}
self.points = []
self.max_hold = False
self.do_log = True
self.colours = ['b', 'r', 'c', 'y']
self.legend = None
self.settings = settings
self.curvewidget.add_toolbar(toolbar, "default")
self.curvewidget.register_all_image_tools()
self.curvewidget.plot.set_axis_title(BasePlot.X_BOTTOM, 'Frequency')
self.addWidget(self.curvewidget)
self.prog = QProgressBar()
self.prog.setMaximumHeight(32)
self.addWidget(self.prog)
self.setStretchFactor(0, 0)
self.setStretchFactor(1, 0)
self.setStretchFactor(2, 1)
self.setHandleWidth(10)
self.setSizes([1, 5, 1])
if start_freq is None:
start_freq = float(
self.settings.value('spectrum/start_freq', 190e6))
if bandwidth is None:
bandwidth = float(self.settings.value('spectrum/bandwidth', 50e6))
if numpts is None:
numpts = int(self.settings.value('spectrum/num_samps', 6000))
print start_freq, bandwidth, numpts
self.settings.setValue('spectrum/start_freq', start_freq)
self.settings.setValue('spectrum/bandwidth', bandwidth)
self.settings.setValue('spectrum/num_samps', numpts)
self.bg7 = BG7(start_freq, bandwidth, numpts, sport=dev)
self.reset_data()
self.bg7.measurement_progress.connect(self.measurement_progress)
self.bg7.measurement_complete.connect(self.measurement_complete)
self.bg7.start()
def reset_data(self):
self.count_data = 0
self.raw_data = {}
self.raw_data['Latest'] = {}
self.raw_data['Max'] = {}
self.raw_data['Mean'] = {}
self.raw_data['Max']['data'] = None
self.raw_data['Logged'] = self.bg7.log_mode
def measurement_progress(self, val):
self.prog.setValue(int(val))
def measurement_complete(self, data, start_freq, step_size, num_samples):
print 'cback', start_freq, step_size
# data, start_freq, step_size, num_samples = cback_data
if data is not None:
if 'Cal Data' in self.raw_data.keys():
self.raw_data['Latest'][
'data'] = data[:] - self.raw_data['Cal Data']['data']
else:
self.raw_data['Latest']['data'] = data[:]
self.raw_data['Latest']['freqs'] = (np.arange(num_samples) *
step_size) + start_freq
self.raw_data['Latest']['freq_units'] = 'MHz'
if self.raw_data['Latest']['freqs'][num_samples / 2] > 1e9:
self.raw_data['Latest']['freqs'] /= 1e9
self.raw_data['Latest']['freq_units'] = 'GHz'
else:
self.raw_data['Latest']['freqs'] /= 1e6
self.curvewidget.plot.set_axis_unit(
BasePlot.X_BOTTOM, self.raw_data['Latest']['freq_units'])
self.show_data('Latest')
if self.count_data == 0:
self.raw_data['Mean'][
'data'] = self.raw_data['Latest']['data'] * 1.0
else:
self.raw_data['Mean']['data'] = ((
(self.raw_data['Mean']['data'] * self.count_data) +
self.raw_data['Latest']['data']) / (self.count_data + 1.0))
self.count_data += 1
self.show_data('Mean')
if self.max_hold:
if self.raw_data['Max']['data'] is None:
self.raw_data['Max']['data'] = self.raw_data['Latest'][
'data']
else:
self.raw_data['Max']['data'][:] = np.maximum(
self.raw_data['Max']['data'],
self.raw_data['Latest']['data'])
self.show_data('Max')
if 'Cal Data' in self.raw_data.keys():
self.show_data('Cal Data')
self.bg7.start()
def save_cal_data(self, fname):
fp = open(fname, 'wb')
cPickle.dump(self.raw_data, fp)
fp.close()
self.settings.setValue('spectrum/file_dir', os.path.dirname(fname))
def load_cal_data(self, fname):
fp = open(fname, 'rb')
cal_data = cPickle.load(fp)
# Add some checks to make sure cal data is valid for our current setup
self.raw_data['Cal Data'] = {}
self.raw_data['Cal Data']['data'] = cal_data['Mean']['data'][:]
fp.close()
self.settings.setValue('spectrum/file_dir', os.path.dirname(fname))
def axes_changed(self, plot):
pass
def show_data(self, label):
data = self.raw_data[label]['data']
xaxis = self.raw_data['Latest']['freqs']
print 'xmin', np.min(xaxis), np.max(xaxis)
self.dshape = data.shape[0]
vals = np.log10(data.shape[0])
if vals > 4:
fact = 10**int(vals - 4)
n = int(data.shape[0] / fact)
print 'Factor', fact, 'N', n
s = data[0:n * fact].reshape(n, fact)
data = np.mean(s, axis=1)
s = xaxis[0:n * fact].reshape(n, fact)
xaxis = np.mean(s, axis=1)
print 'Min', np.min(data), 'Max', np.max(data), data.shape
print 'dshape', self.dshape
if label in self.item.keys():
if self.do_log:
self.item[label].set_data(xaxis, data)
else:
self.item[label].set_data(xaxis, np.log10(data))
else:
if self.do_log:
self.item[label] = make.curve(
xaxis,
data,
color=self.colours[len(self.item) % len(self.colours)],
title=label)
else:
self.item[label] = make.curve(
xaxis,
data,
color=self.colours[len(self.item) % len(self.colours)],
title=label)
self.curvewidget.plot.add_item(self.item[label])
self.curvewidget.plot.set_antialiasing(True)
if self.legend is None:
self.legend = make.legend("TR")
self.curvewidget.plot.add_item(self.legend)
self.item[label].plot().replot()
def rescan(self):
print self.curvewidget.plot.get_axis_limits(BasePlot.X_BOTTOM)
ax = self.curvewidget.plot.get_axis_limits(BasePlot.X_BOTTOM)
un = self.curvewidget.plot.get_axis_unit(BasePlot.X_BOTTOM)
if un == 'MHz':
factor = 1e6
elif un == 'GHz':
factor = 1e9
else:
factor = 1.0
self.reset_data()
self.bg7.setParams(ax[0] * factor, (ax[1] - ax[0]) * factor)
self.settings.setValue('spectrum/start_freq', ax[0] * factor)
self.settings.setValue('spectrum/bandwidth', (ax[1] - ax[0]) * factor)
#self.bg7.start()
def do_max_hold(self):
self.max_hold = not self.max_hold
self.settings.setValue('gui/max_hold', self.max_hold)
def do_log_lin(self, new_state):
self.bg7.do_log(new_state)
self.reset_data()
# self.settings.setValue('gui/log_lin', new_state)
def do_new_plot(self):
pass
class MainWidget(QSplitter):
def __init__(self, parent, toolbar):
QSplitter.__init__(self, parent)
self.data_ref = None
self.setContentsMargins(10, 10, 10, 10)
self.setOrientation(Qt.Vertical)
dsinfo = DSInfo(self)
self.addWidget(dsinfo)
dsproperties = DSProperties(self)
self.addWidget(dsproperties)
imagelistwithproperties = ImageListWithProperties(self)
self.addWidget(imagelistwithproperties)
self.imagelist = imagelistwithproperties.imagelist
self.imagelist.currentRowChanged.connect(self.current_item_changed)
self.imagelist.itemSelectionChanged.connect(self.selection_changed)
self.ds = dsproperties.datas
self.info = dsinfo.datas
self.ds.SIG_APPLY_BUTTON_CLICKED.connect(self.properties_changed)
self.properties = imagelistwithproperties.properties
self.properties.SIG_APPLY_BUTTON_CLICKED.connect(
self.properties_changed)
self.imagewidget = CurveWidget(self)
self.item = None
self.flagitem = None
self.flagname = ""
self.imagewidget.add_toolbar(toolbar, "default")
self.imagewidget.register_standard_tools()
flag = create_action(self,
_("Get preflag from file..."),
icon=get_icon('eraser.png'),
tip=_("Get a preflag from file"),
triggered=self.preflag)
fit = create_action(self,
_("Open fit window..."),
icon=get_icon('polyline.png'),
tip=_("Open fit window"),
triggered=self.fit_win)
#apply = create_action(self, _("Apply fit file..."),
# icon=get_icon('export.png'), tip=_("Apply fit file"),
# triggered=self.apply_fit)
add_actions(toolbar, [None, flag, fit])
self.addWidget(self.imagewidget)
self.images = []
self.setStretchFactor(0, 0)
self.setStretchFactor(1, 1)
self.setHandleWidth(10)
self.setSizes([50, 100, 200, 600])
def set_data_ref(self, data_ref):
self.data_ref = data_ref
self.data_ref.flag = None
def set_images(self, data_ref):
for dataset in data_ref.dir_datasets:
image = ImageParam()
image.title = dataset.title
image.otype = dataset.otype
image.selected = dataset.selected
self.images.append(image)
def set_ds_selector(self):
#c_polar = [("l", "l"), ("r", "r")]
#choices.set(c_polar)
#print choices.__call__()
self.dssel = DSParam()
def open_setup(self, data_ref):
self.set_data_ref(data_ref)
self.set_images(data_ref)
self.set_ds_selector()
self.refresh_list()
self.update_info()
# def refresh_list(self):
# self.imagelist.clear()
# self.imagelist.addItems([image.title for image in self.images])
def refresh_list(self):
self.imagelist.clear()
for image in self.images:
item = QListWidgetItem(image.title)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(2 if image.selected else 0)
self.imagelist.addItem(item)
def selection_changed(self):
row = self.imagelist.currentRow()
self.properties.setDisabled(row == -1)
def current_item_changed(self, row):
self.image = self.images[row]
med = self.data_ref.get_median_data([row], self.dssel.section,
self.dssel.polar,
[self.image.rangei],
[self.image.ranges],
[self.image.excluded])
self.image.x = med[0]
self.image.y = med[1]
self.show_data(self.image.x, self.image.y, self.data_ref.flag)
update_dataset(self.properties.dataset, self.image)
self.properties.get()
self.update_info()
def show_data(self, x, y, flag=None):
plot = self.imagewidget.plot
if self.item is not None:
self.item.set_data(x, y)
else:
self.item = make.curve(x, y, color='blue')
plot.add_item(self.item, z=0)
if flag is not None:
if self.flagitem is not None:
self.flagitem.set_data(x, flag * y)
else:
self.flagitem = make.curve(x, flag * y, color='green')
plot.add_item(self.flagitem, z=0)
plot.replot()
def update_info(self):
row = self.imagelist.currentRow()
ds = self.data_ref.dir_datasets[row]
self.info.dataset.feed = self.dssel.feed
self.info.dataset.section = self.dssel.section
d = {"0": "L", "1": "R", "2": "Q", "3": "U"}
self.info.dataset.polar = d[self.dssel.polar]
self.info.dataset.freq = self.data_ref.dw_io.get_frequency(ds.th)
self.info.dataset.band = self.data_ref.dw_io.get_bandwidth(
ds.th, self.dssel.section, d[self.dssel.polar])
self.info.dataset.otype = ds.otype
self.info.dataset.flagname = self.flagname
self.info.get()
def properties_changed(self):
row = self.imagelist.currentRow()
image = self.images[row]
try:
image.x
except:
pass
else:
if ((self.properties.dataset.franges != 0
and self.properties.dataset.franges < len(image.x)
and self.properties.dataset.frangei <
self.properties.dataset.franges)
or (self.properties.dataset.franges == 0
and self.properties.dataset.frangei < len(image.x))):
pass
else:
msgBox = QMessageBox()
msgBox.setText(
"Fit range void or out of bound! Range max 0:%s" %
(len(image.x) - 1))
msgBox.exec_()
return -1
update_dataset(image, self.properties.dataset)
#self.dssel.section = self.data_ref.list2choices(self.data_ref.sections[int(self.ds.dataset.feed)])
csections.set(
self.data_ref.list2choices(self.data_ref.sections[int(
self.ds.dataset.feed)]))
update_dataset(self.dssel, self.ds.dataset)
self.update_info()
if self.flagname:
self.data_ref.flag = self.data_ref.get_flag_curve(
self.flagname, self.dssel.section)
#for i in self.images:
# i.otype = image.otype
if image.rall == True:
for i in self.images:
i.rangei = image.rangei
i.ranges = image.ranges
if image.eall == True:
for i in self.images:
i.excluded = image.excluded
for i in self.images:
i.frangei = image.frangei
i.franges = image.franges
try:
self.show_data(image.x, image.y, self.data_ref.flag)
except:
pass
def preflag(self):
filename = getopenfilename(self, _("Open"), "")
if not str(filename[0]):
return -1
else:
#try:
self.flagname = str(filename[0])
self.data_ref.flag = self.data_ref.get_flag_curve(
self.flagname, self.dssel.section)
self.properties_changed()
#except:
# msgBox = QMessageBox()
# msgBox.setText("Wrong file!")
# msgBox.exec_()
# return -1
def get_gmedian(self):
ldata = []
liran = []
lsran = []
lexcl = []
for i in enumerate(self.images):
if self.imagelist.item(i[0]).checkState() == 2:
ldata.append(i[0])
liran.append(i[1].rangei)
lsran.append(i[1].ranges)
lexcl.append(i[1].excluded)
if len(ldata) != 0:
self.data_ref.dssel = [
self.dssel.feed, self.dssel.section, self.dssel.polar
]
self.data_ref.gmed = self.data_ref.get_median_data(
ldata, self.dssel.section, self.dssel.polar, liran, lsran,
lexcl)
else:
return -1
def fit_win(self):
self.fwindow = FitWindow()
#try:
self.get_gmedian()
self.fwindow.get_data(self.data_ref, self.images[0].frangei,
self.images[0].franges)
self.fwindow.show()
#except:
# msgBox = QMessageBox()
# msgBox.setText("Selection empty!")
# msgBox.exec_()
# return -1
def apply_fit(self):
msgBox = QMessageBox()
msgBox.setText("Apply corrections?")
msgBox.setInformativeText(
"Select to which files will be applied the correction.")
CancelButton = msgBox.addButton("Cancel", msgBox.RejectRole)
SelectButton = msgBox.addButton("Select", msgBox.NoRole)
AllButton = msgBox.addButton("All", msgBox.YesRole)
#msgBox.setDefaultButton(QMessageBox.Cancel)
msgBox.exec_()
if msgBox.clickedButton() == CancelButton:
return -1
elif msgBox.clickedButton() == AllButton:
filelist = None
elif msgBox.clickedButton() == SelectButton:
flret = getopenfilenames(self, _("Select file list"),
self.data_ref.dir_name)[0]
filelist = []
for f in flret:
filelist.append((basename(str(f)), dirname(str(f))))
msgBox = QMessageBox()
msgBox.setText("Select the correction file")
msgBox.addButton(QMessageBox.Ok)
msgBox.exec_()
filename = getopenfilename(
self, _("Correction file"),
self.data_ref.dir_name + "/" + basename(
normpath(self.data_ref.dir_name) + "_fit." +
self.data_ref.files_type))
try:
self.data_ref.applycorr(str(filename[0]), filelist)
except:
msgBox = QMessageBox()
msgBox.setText("Not a correction file!")
msgBox.exec_()
return -1
