def get_day_layout(self, day_text):
day_label = QLabel(day_text)
day_label.setFixedWidth(120)
day_label.setFixedHeight(50)
day_label.setFont(self.day_font)
day_label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
gen_day_button = QPushButton("Plan day")
gen_day_button.setFont(self.general_font)
gen_day_button.font().setBold(False)
use_day_check = QCheckBox("Use: ")
use_day_check.setLayoutDirection(QtCore.Qt.RightToLeft)
use_day_check.setChecked(True)
use_day_check.setFont(self.general_font)
day_layout = QHBoxLayout()
day_layout.addWidget(day_label)
day_layout.addWidget(use_day_check)
info_layout = QVBoxLayout()
info_layout.addLayout(day_layout)
info_layout.addWidget(gen_day_button)
day_text_edit = QTextEdit()
day_text_edit.setFont(self.general_font)
#Create, fill and return the day layout
day_layout = QHBoxLayout()
day_layout.addLayout(info_layout)
day_layout.addWidget(day_text_edit)
return day_layout
class CamView(AbstractView):
def __init__(self,
name: str = "CAM_NONE",
log_handlers: [StreamHandler] = None):
self._logger = getLogger(__name__)
if log_handlers:
for h in log_handlers:
self._logger.addHandler(h)
self._logger.debug("Initializing")
super().__init__(name)
""" Min size for cam window """
self._subwindow_height = 222
self._subwindow_width = 518
self._initialization_bar_frame = EasyFrame()
self._initialization_bar_frame.setMouseTracking(True)
self._initialization_bar_frame.setMaximumHeight(70)
self._initialization_bar_layout = QVBoxLayout(
self._initialization_bar_frame)
self._initialization_bar_label = QLabel(self._initialization_bar_frame)
self._initialization_bar_label.setMouseTracking(True)
self._initialization_bar = QProgressBar(self._initialization_bar_frame)
self._initialization_bar.setMouseTracking(True)
self._initialization_bar.setMaximumHeight(15)
self._initialization_bar.setTextVisible(True)
self._initialization_bar.setAlignment(Qt.AlignHCenter)
self._initialization_bar_layout.addWidget(
self._initialization_bar_label)
self._initialization_bar_layout.addWidget(self._initialization_bar)
self._cam_settings_frame = EasyFrame()
self._cam_settings_layout = QGridLayout(self._cam_settings_frame)
self._resolution_selector_label = QLabel(self._cam_settings_frame)
self._resolution_selector_label.setAlignment(Qt.AlignLeft)
self._resolution_selector = QComboBox(self._cam_settings_frame)
self._resolution_selector.setMaximumHeight(22)
self._cam_settings_layout.addWidget(self._resolution_selector_label, 0,
0)
self._cam_settings_layout.addWidget(self._resolution_selector, 0, 1)
self._fps_selector_label = QLabel(self._cam_settings_frame)
self._fps_selector_label.setAlignment(Qt.AlignLeft)
self._fps_selector = QComboBox(self._cam_settings_frame)
self._fps_selector.setMaximumHeight(22)
self._cam_settings_layout.addWidget(self._fps_selector_label, 1, 0)
self._cam_settings_layout.addWidget(self._fps_selector, 1, 1)
self._show_feed_checkbox_label = QLabel(self._cam_settings_frame)
self._show_feed_checkbox_label.setAlignment(Qt.AlignLeft)
self._show_feed_checkbox = QCheckBox()
self._show_feed_checkbox.setChecked(True)
self._show_feed_checkbox.setLayoutDirection(Qt.RightToLeft)
self._cam_settings_layout.addWidget(self._show_feed_checkbox_label, 2,
0)
self._cam_settings_layout.addWidget(self._show_feed_checkbox, 2, 1)
self._use_cam_checkbox_label = QLabel(self._cam_settings_frame)
self._use_cam_checkbox_label.setAlignment(Qt.AlignLeft)
self._use_cam_checkbox = QCheckBox()
self._use_cam_checkbox.setChecked(True)
self._use_cam_checkbox.setLayoutDirection(Qt.RightToLeft)
self._cam_settings_layout.addWidget(self._use_cam_checkbox_label, 3, 0)
self._cam_settings_layout.addWidget(self._use_cam_checkbox, 3, 1)
self._use_overlay_checkbox_label = QLabel(self._cam_settings_frame)
self._use_overlay_checkbox_label.setAlignment(Qt.AlignLeft)
self._use_overlay_checkbox = QCheckBox()
self._use_overlay_checkbox.setChecked(True)
self._use_overlay_checkbox.setLayoutDirection(Qt.RightToLeft)
self._cam_settings_layout.addWidget(self._use_overlay_checkbox_label,
4, 0)
self._cam_settings_layout.addWidget(self._use_overlay_checkbox, 4, 1)
self._image_display_frame = EasyFrame()
self._image_display_layout = QVBoxLayout(self._image_display_frame)
self._image_display_label = QLabel(self._image_display_frame)
self._image_display_label.setAlignment(Qt.AlignHCenter)
self._image_display = QLabel(self._image_display_frame)
self._image_display.setAlignment(Qt.AlignCenter)
self._image_display.setMouseTracking(True)
self._image_display_layout.addWidget(self._image_display_label)
self._image_display_layout.addWidget(self._image_display)
spacer = QSpacerItem(1, 1, vData=QSizePolicy.Expanding)
self._dev_sets_frame = EasyFrame()
self._dev_sets_layout = QVBoxLayout(self._dev_sets_frame)
self.config_button = ClickAnimationButton()
self.config_button.clicked.connect(self._config_button_handler)
self.layout().addWidget(self.config_button, 0, 0,
Qt.AlignTop | Qt.AlignRight)
self.config_button.setFixedSize(30, 25)
self.config_button.setStyleSheet(
"background-color: rgba(200, 200, 200, 50%)")
self._dev_sets_layout.addWidget(self._cam_settings_frame)
self._dev_sets_layout.addItem(spacer)
self.layout().addWidget(self._image_display, 0, 0)
self.layout().addWidget(self._initialization_bar_frame, 0, 0)
self._config_items = [
self._resolution_selector,
self._fps_selector,
self._use_cam_checkbox,
self._show_feed_checkbox,
self._use_overlay_checkbox,
]
config_win_w = 350
config_win_h = len(self._config_items) * 30
self.config_button.raise_()
self._config_win = ConfigPopUp()
self._config_win.setLayout(self._dev_sets_layout)
self._config_win.setFixedSize(config_win_w, config_win_h)
self._rec_label = QLabel()
self._rec_label.setStyleSheet(
"background-color: rgba(0, 0, 0, 0%); color: red; font: 20px")
self._rec_label.hide()
self.layout().addWidget(self._rec_label, 0, 0,
Qt.AlignBottom | Qt.AlignRight)
self.layout().setMargin(0)
self._window_changing = False
self._showing_images = False
self._hidden = False
w = 320
self._aspect_ratio = 9 / 16
self.resize(w, self.heightForWidth(w))
self._strings = dict()
self._lang_enum = LangEnum.ENG
self.setMinimumSize(self._subwindow_width, self._subwindow_height)
self.old_size = QSize(self.width(), self.height())
self._logger.debug("Initialized")
def set_show_feed_button_handler(self, func) -> None:
"""
Add handler for show camera selector.
:param func: The handler.
:return None:
"""
self._logger.debug("running")
self._show_feed_checkbox.toggled.connect(func)
self._logger.debug("done")
def set_resolution_selector_handler(self, func) -> None:
"""
Add handler for resolution selector.
:param func: The handler.
:return None:
"""
self._logger.debug("running")
self._resolution_selector.activated.connect(func)
self._logger.debug("done")
def set_fps_selector_handler(self, func) -> None:
"""
Add handler for resolution selector.
:param func: The handler.
:return None:
"""
self._logger.debug("running")
self._fps_selector.activated.connect(func)
self._logger.debug("done")
def set_use_cam_button_handler(self, func) -> None:
"""
Add handler for use camera selector.
:param func: The handler.
:return None:
"""
self._logger.debug("running")
self._use_cam_checkbox.toggled.connect(func)
self._logger.debug("done")
def set_use_overlay_button_handler(self, func) -> None:
"""
Add handler for use camera selector.
:param func: The handler.
:return None:
"""
self._logger.debug("running")
self._use_overlay_checkbox.toggled.connect(func)
self._logger.debug("done")
def _config_button_handler(self) -> None:
"""
Show config pop up.
:return None:
"""
self._logger.debug("running")
self.config_button.setStyleSheet(
"background-color: rgba(200, 200, 200, 50%)")
self._config_win.exec_()
self._logger.debug("done")
@property
def language(self) -> LangEnum:
"""
:return: The current lang enum being used.
"""
return self._lang_enum
@language.setter
def language(self, lang: LangEnum) -> None:
"""
Set the language for this view object.
:param lang: The language to use.
:return None:
"""
self._logger.debug("running")
self._lang_enum = lang
self._strings = strings[lang]
self._set_texts()
self._set_tooltips()
self._logger.debug("done")
@property
def resolution_list(self) -> list:
"""
Get list of resolutions.
:return list: The list of resolutions.
"""
ret = list()
return ret
@resolution_list.setter
def resolution_list(self, res_list: list) -> None:
"""
Set list of resolutions available to res_list.
:param res_list: The list of available resolutions.
:return None:
"""
self._logger.debug("running")
self._resolution_selector.clear()
for item in res_list:
self._resolution_selector.addItem(str(item))
self._logger.debug("done")
@property
def resolution(self) -> str:
"""
Get the current resolution selection.
:return str: The current resolution.
"""
return self._resolution_selector.currentText()
@resolution.setter
def resolution(self, res: str) -> None:
"""
Set the current resolution selection.
:param res: The resolution to set to.
:return None:
"""
self._resolution_selector.setCurrentIndex(
self._resolution_selector.findText(res))
@property
def fps_list(self) -> list:
"""
Get list of fps options.
:return list: The list of fps options.
"""
ret = list()
return ret
@fps_list.setter
def fps_list(self, fps_list: list) -> None:
"""
Set list of available fps to fps_list.
:param fps_list:
:return None:
"""
self._logger.debug("running")
self._fps_selector.clear()
for item in fps_list:
self._fps_selector.addItem(str(item))
self._logger.debug("done")
@property
def fps(self) -> str:
"""
Get the current fps selection.
:return str: The current fps selection.
"""
return self._fps_selector.currentText()
@fps.setter
def fps(self, fps: str) -> None:
"""
Set the current fps selection.
:param fps: The fps to set to.
:return None:
"""
self._logger.debug("running")
self._fps_selector.setCurrentIndex(self._fps_selector.findText(fps))
self._logger.debug("done")
@property
def use_feed(self) -> bool:
"""
Get the current use_cam setting.
:return bool: User selection for using cam.
"""
return self._show_feed_checkbox.isChecked()
@use_feed.setter
def use_feed(self, useable: bool) -> None:
"""
Set use_cam setting.
:param useable: The setting to set to.
:return None:
"""
self._logger.debug("running")
self._show_feed_checkbox.setChecked(useable)
self._logger.debug("Done")
@property
def use_cam(self) -> bool:
"""
Get the current use_cam setting.
:return bool: User selection for using cam.
"""
return self._use_cam_checkbox.isChecked()
@use_cam.setter
def use_cam(self, useable: bool) -> None:
"""
Set use_cam setting.
:param useable: The setting to set to.
:return None:
"""
self._logger.debug("running")
self._use_cam_checkbox.setChecked(useable)
self._logger.debug("Done")
@property
def use_overlay(self) -> bool:
"""
Get the current use_overlay setting.
:return bool: User selection for using overlay.
"""
return self._use_overlay_checkbox.isChecked()
@use_overlay.setter
def use_overlay(self, useable: bool) -> None:
"""
Set use_overlay setting.
:param useable: The setting to set to.
:return None:
"""
self._logger.debug("running")
self._use_overlay_checkbox.setChecked(useable)
self._logger.debug("Done")
def heightForWidth(self, w: int) -> int:
return int(w * self._aspect_ratio)
def widthForHeight(self, h: int) -> int:
return int(h / self._aspect_ratio)
def hideEvent(self, hideEvent: QHideEvent):
"""
Track minimize event.
:param hideEvent:
:return None:
"""
self._hidden = True
def showEvent(self, showEvent: QShowEvent):
"""
Track restore event.
:param showEvent:
:return None:
"""
self._hidden = False
def update_image(self, image: QPixmap = None, msg: str = None) -> None:
"""
Update image viewer with new image.
:param image: The new image to show.
:param msg: The text to show if no image.
:return None:
"""
self._logger.debug("running")
if not self._window_changing:
if image is not None:
temp_image_w = image.scaledToWidth(self.width() - 15)
temp_image_h = image.scaledToHeight(self.height() - 35)
if temp_image_w.height() > self.height() - 35:
self._image_display.setPixmap(temp_image_h)
else:
self._image_display.setPixmap(temp_image_w)
elif msg is not None:
self._image_display.setText(msg)
self._logger.debug("done")
def show_images(self) -> None:
"""
Show image display and hide initialization bar.
:return None:
"""
self._logger.debug("running")
geo = self.geometry()
self._showing_images = True
self._initialization_bar_frame.hide()
self._image_display.show()
self.config_button.show()
self.setStyleSheet("background-color: black")
self.setGeometry(geo)
self._logger.debug("done")
def show_initialization(self) -> None:
"""
Show initialization bar and hide image display.
:return None:
"""
self._logger.debug("running")
self._showing_images = False
self._image_display.hide()
self.config_button.hide()
self._initialization_bar_frame.show()
self._logger.debug("done")
def update_init_bar(self, progress: int) -> None:
"""
set progress bar value to progress.
:param progress: The value to set progress bar to.
:return None:
"""
self._logger.debug("running")
if progress > 100:
progress = 100
elif progress < 0:
progress = 0
self._initialization_bar.setValue(progress)
self._logger.debug("done")
def set_config_active(self, is_active: bool) -> None:
"""
Set whether this camera config options are usable.
:param is_active: Usable.
:return None:
"""
self._logger.debug("running")
if self._showing_images:
if is_active:
self._rec_label.hide()
elif self.use_cam:
self._rec_label.show()
for item in self._config_items:
item.setEnabled(is_active)
self._logger.debug("done")
def _set_texts(self) -> None:
"""
Set the texts in this view object.
:return None:
"""
self._logger.debug("running")
self._initialization_bar_label.setText(
self._strings[StringsEnum.INITIALIZATION_BAR_LABEL])
self._initialization_bar.setValue(0)
self._image_display_label.setText(
self._strings[StringsEnum.IMAGE_DISPLAY_LABEL])
self._image_display.setText(self._strings[StringsEnum.IMAGE_DISPLAY])
self._show_feed_checkbox_label.setText(
self._strings[StringsEnum.SHOW_FEED_CHECKBOX_LABEL])
self._use_cam_checkbox_label.setText(
self._strings[StringsEnum.USE_CAM_CHECKBOX_LABEL])
self._use_overlay_checkbox_label.setText(
self._strings[StringsEnum.USE_OVERLAY_CHECKBOX_LABEL])
self._resolution_selector_label.setText(
self._strings[StringsEnum.RESOLUTION_SELECTOR_LABEL])
self._fps_selector_label.setText(
self._strings[StringsEnum.FPS_SELECTOR_LABEL])
self._config_win.setWindowTitle(
self.get_name() + " " +
self._strings[StringsEnum.CONFIG_TAB_LABEL])
self.config_button.setText("...")
self._rec_label.setText("rec ●")
self._logger.debug("done")
def _set_tooltips(self) -> None:
"""
Set the tooltips in this view object.
:return None:
"""
self._logger.debug("running")
self._resolution_selector_label.setToolTip(
self._strings[StringsEnum.RESOLUTION_SELECTOR_TOOLTIP])
self._resolution_selector.setToolTip(
self._strings[StringsEnum.RESOLUTION_SELECTOR_TOOLTIP])
self._fps_selector_label.setToolTip(
self._strings[StringsEnum.FPS_SELECTOR_TOOLTIP])
self._fps_selector.setToolTip(
self._strings[StringsEnum.FPS_SELECTOR_TOOLTIP])
self._show_feed_checkbox_label.setToolTip(
self._strings[StringsEnum.SHOW_FEED_CHECKBOX_TOOLTIP])
self._show_feed_checkbox.setToolTip(
self._strings[StringsEnum.SHOW_FEED_CHECKBOX_TOOLTIP])
self._use_cam_checkbox_label.setToolTip(
self._strings[StringsEnum.USE_CAM_CHECKBOX_TOOLTIP])
self._use_cam_checkbox.setToolTip(
self._strings[StringsEnum.USE_CAM_CHECKBOX_TOOLTIP])
self._use_overlay_checkbox_label.setToolTip(
self._strings[StringsEnum.USE_OVERLAY_TOOLTIP])
self._use_overlay_checkbox.setToolTip(
self._strings[StringsEnum.USE_OVERLAY_TOOLTIP])
self._image_display.setToolTip(
self._strings[StringsEnum.IMAGE_DISPLAY_TOOLTIP])
self._logger.debug("done")
class extractPeaksDialog(QDialog):
def __init__(self, *args, **kwargs):
super(extractPeaksDialog, self).__init__(*args, **kwargs)
self.peaksScraped = False
self.small = 3
self.failures_nulled = False
self.rundownThreshold = 0.5 # to assess whether responses are running down (by factor 2 or more)
self.makeDialog()
def makeDialog(self):
"""Create the controls for the dialog"""
self.setWindowTitle("Extract peaks according to reference pattern")
layout = QGridLayout()
w = QWidget()
w.setLayout(layout)
self.resize(500, 400)
vbox = QVBoxLayout()
vbox.addWidget(w)
self.setLayout(vbox)
self.N_ROI_label = QLabel('Extracting peaks')
#will be altered as soon as data loads
self.skipRB = QCheckBox('Skip ROIs with SNR less than')
self.skipRB.setChecked(False)
self.skipRB.setLayoutDirection(QtCore.Qt.LeftToRight)
self.skipRB.stateChanged.connect(self.maskLowSNR)
self.skipSB = pg.SpinBox(value=3, step=.2, bounds=[1, 10], delay=0)
self.skipSB.setFixedSize(60, 25)
self.skipSB.valueChanged.connect(self.maskLowSNR)
psr_label = QLabel('Search range around peak (data points)')
self.psrSB = pg.SpinBox(value=3,
step=2,
bounds=[1, 7],
delay=0,
int=True)
self.psrSB.setFixedSize(60, 25)
#will be altered as soon as data loads
self.noiseRB = QCheckBox('Treat peaks as failures when < SD x')
self.noiseRB.setChecked(False)
self.noiseRB.setLayoutDirection(QtCore.Qt.LeftToRight)
self.noiseRB.stateChanged.connect(self.setFailures)
self.noiseRB.setDisabled(True)
self.noiseSB = pg.SpinBox(value=1.5, step=.1, bounds=[.2, 10], delay=0)
self.noiseSB.setFixedSize(60, 25)
self.noiseSB.valueChanged.connect(self.setFailures)
self.noiseSB.setDisabled(True)
self.peaksLabel = QLabel('No peaks set to be failures.')
_doScrapeBtn = QPushButton('Extract responses')
_doScrapeBtn.clicked.connect(self.scrapePeaks)
self.getRundownBtn = QPushButton('Calculate rundown')
self.getRundownBtn.clicked.connect(self.getRundown)
self.getRundownBtn.setDisabled(True)
_cancelBtn = QPushButton('Cancel')
_cancelBtn.clicked.connect(self.reject)
self.acceptBtn = QPushButton('Accept and Return')
self.acceptBtn.clicked.connect(self.prepareAccept)
self.acceptBtn.setDisabled(True)
layout.addWidget(self.N_ROI_label, 0, 0, 1, 2)
layout.addWidget(self.skipRB, 1, 0, 1, 3)
layout.addWidget(self.skipSB, 1, 2, 1, 1)
layout.addWidget(psr_label, 2, 0, 1, 2)
layout.addWidget(self.psrSB, row=2, col=2)
layout.addWidget(self.noiseRB, 3, 0, 1, 3)
layout.addWidget(self.noiseSB, 3, 2, 1, 1)
layout.addWidget(self.peaksLabel, 4, 0, 1, -1)
layout.addWidget(_doScrapeBtn, 5, 0)
layout.addWidget(self.getRundownBtn, 5, 1)
layout.addWidget(_cancelBtn, 6, 1)
layout.addWidget(self.acceptBtn, 6, 2)
self.setLayout(layout)
def setExternalParameters(self, extPa):
"""extPa is a dictionary of external parameters that can be passed"""
if 'Max' in extPa:
self.selecter.setMaximum(extPa['Max'])
print("Changing spinbox max to : {}".format(extPa['Max']))
if 'Min' in extPa:
self.selecter.setMinimum(extPa['Min'])
print("Changing spinbox min to : {}".format(extPa['Min']))
if 'tPeaks' in extPa:
self.tPeaks = extPa['tPeaks']
def prepGuiParameters(self):
"""Take parameters specified by GUI"""
#True if box is checked, otherwise False
self.ignore = self.skipRB.isChecked()
self.psr = self.psrSB.value() // 2 #floor division to get ears
def addDataset(self, data):
"""Bring in external dataset for analysis"""
self.tracedata = data.traces # each dataframe in this dictionary could have a different set of ROI
self.name = data.DSname + "_expk"
tdk = self.tracedata.keys()
tdk_display = ", ".join(str(k) for k in tdk)
N_ROI = np.array([len(self.tracedata[d].columns) for d in tdk])
N_Peaks = len(self.tPeaks)
self.total_peaks = (N_ROI * N_Peaks).sum()
self.N_ROI_label.setText(
"Extracting {} peaks from {} ROIs (total {})\n over the sets named {}"
.format(N_Peaks, N_ROI, self.total_peaks, tdk_display))
_printable = "{}\n{}\n".format(tdk_display,
[self.tracedata[d].head() for d in tdk])
print("Added data of type {}:\n{}\n".format(type(self.tracedata),
_printable))
self.maskLowSNR()
def getRundown(self, silent=False):
rtext = ""
self.rundownCount = 0
for _condi, _pkdf in self.pk_extracted_by_condi.items():
_Np = len(_pkdf.index)
_NROI = len(_pkdf.columns)
ten_percent = int(_Np / 10)
rtext += "{} condition, 10% of peaks count is {} peaks\n".format(
_condi, ten_percent)
# look at first 5 peaks
_firsttenpc = _pkdf.iloc[0:ten_percent].describe().loc["mean"]
# look at last 5 peaks
_lasttenpc = _pkdf.iloc[-1 - ten_percent:-1].describe().loc["mean"]
_tdf = self.tracedata[_condi]
_max = _tdf.max()
_SD = _tdf.std()
_bestSNR = _max / _SD
_startSNR = _firsttenpc / _SD
_endSNR = _lasttenpc / _SD
#print ("ff, lf : {} {}".format(_firstfive, _lastfive))
_rundownRatio = _lasttenpc.div(_firsttenpc).sort_values()
self.rundownCount += _rundownRatio[
_rundownRatio < self.rundownThreshold].count()
_rd_SNR = pd.concat([_rundownRatio, _bestSNR, _startSNR, _endSNR],
axis=1)
_rd_SNR.columns = [
'Rundown', 'Best SNR', 'Initial SNR', 'Final SNR'
]
rtext += "Rundown (amplitude ratio: last 10% / first 10%) and signal to noise ratio (start, end)\nfor {} ROIs (ROIs with worst rundown first):\n{}\n\n".format(
_NROI,
_rd_SNR.round(2).to_string())
rtext += "Total number of traces with rundown worse than threshold ({}): {}\n".format(
self.rundownThreshold, self.rundownCount)
print(rtext)
if not silent:
###Make a pop up window of these results
qmb = QDialog()
qmb.setWindowTitle('Rundown {}'.format(self.name))
qmb.setGeometry(800, 600, 600, 600)
self.rundownText = QtGui.QTextEdit()
font = QtGui.QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(12)
self.rundownText.setCurrentFont(font)
self.rundownText.setText(rtext)
self.rundownText.setReadOnly(True)
#add buttons, make it the right size
qmb.layout = QVBoxLayout()
qmb.layout.addWidget(self.rundownText)
qmb.setLayout(qmb.layout)
qmb.exec_()
def scrapePeaks(self):
"""Some peak-finding function with output filtering based on SNR"""
self.prepGuiParameters()
self.pk_extracted_by_condi = {}
for _condi in self.tracedata.keys():
maxVal = len(self.tPeaks)
ROI_df = self.tracedata[_condi]
#print (ROI_df)
peaksList = []
progMsg = "Get {0} peaks, {1} set..".format(maxVal, _condi)
with pg.ProgressDialog(progMsg, 0, maxVal) as dlg:
dlg.setMinimumWidth(300)
for t in self.tPeaks:
dlg += 1
idx = np.searchsorted(ROI_df.index, t)
# avoid falling off start or end of columns
e = max(idx - self.psr, 0)
# zero biased so add one.
l = min(idx + self.psr + 1, len(ROI_df.index))
print(t, e, idx, l, ROI_df.iloc[e:l])
p = ROI_df.iloc[e:l].max().to_frame().transpose()
peaksList.append(p)
#stick rows together (all have same zero index...)
peaksdf = pd.concat(peaksList)
# Overwrite index with the original peak positions
# (somewhat inexact because of the 'range')
peaksdf.index = self.tPeaks
self.pk_extracted_by_condi[_condi] = peaksdf
# yes, output may be modified below
self.peaksScraped = True
self.acceptBtn.setEnabled(True)
self.getRundownBtn.setEnabled(True)
self.noiseRB.setEnabled(True)
self.noiseSB.setEnabled(True)
self.excludedListedByCondi = {}
if self.ignore:
# freshly excludedList peaks from traces with low SNR
self.maskLowSNR()
self.splitAllowedExcluded()
def splitAllowedExcluded(self):
# the cut-off value
_cut = self.excludeSNRcut
#split peak data into sets from high and low SNR
for s in self.pk_extracted_by_condi.keys():
wls = self.allowedLists[s]
bls = self.excludedLists[s]
pk = self.pk_extracted_by_condi[s]
allowedListed = pk[wls.sort_values(ascending=False).index]
excludedListed = pk[bls.sort_values(ascending=False).index]
self.pk_extracted_by_condi[s] = allowedListed
self.excludedListedByCondi[s + "_SNR<" +
str(_cut)] = excludedListed
def prepareAccept(self):
# substitute failures (destructively)
if self.failures_nulled:
self.pk_extracted_by_condi = self.pk_extracted_with_failures
# divide peak results into Allowed list and Excluded list based on SNR
self.splitAllowedExcluded()
self.accept()
def setFailures(self):
self.failures_nulled = True
# setting failures modifies the output destructively and must retain original!!!
self.pk_extracted_with_failures = self.pk_extracted_by_condi.copy(
) #is that enough?
if self.noiseRB.isChecked == False:
self.noiseSB.setDisabled(True)
return
else:
self.noiseSB.setEnabled(True)
# in allowedList traces
self.noiseCut = self.noiseSB.value()
print("Self.noisecut {}".format(self.noiseCut))
_numberCut = 0
for _condi in self.tracedata:
_peaksDF = self.pk_extracted_with_failures[_condi]
_df = self.tracedata[_condi]
#print (_df)
_noise = _df.std()
#print ("NOISE: ", _noise)
_peaksDF = _peaksDF.where(_peaksDF > _noise * self.noiseCut, 0)
#print ("peaksdf",_peaksDF )
_bycol = _peaksDF.isin([0.0]).sum()
#print ("bycol {} sum {}".format(_bycol, _bycol.sum()))
_numberCut += _bycol.sum()
self.pk_extracted_with_failures[_condi] = _peaksDF
# Provide some indication of total peaks altered interactively
self.peaksLabel.setText(
"{} peaks set as failures ({: .1f}% of total).".format(
_numberCut, 100 * _numberCut / self.total_peaks))
def maskLowSNR(self):
"""split the peak output according to SNR of parent traces"""
"""moving the spinbox for SNR Cutoff also comes here"""
print('maskLowSNR')
if self.skipRB.isChecked == False:
self.skipSB.setDisabled(True)
return
else:
self.skipSB.setEnabled(True)
self.excludeSNRcut = self.skipSB.value()
# use selective region (LR?)
# or just the whole trace?
#store allowedLists and excludedLists as values with the set as key.
self.allowedLists = {}
self.excludedLists = {}
self.allowedCount = 0
self.excludedCount = 0
for _condi, _tdf in self.tracedata.items():
#_df = self.tracedata[_condi]
# find SNR from column-wise Max / SD
_max = _tdf.max()
_SD = _tdf.std()
snr = _max / _SD
#print ("max {}, sd {}, snr {}".format(_max, _SD, snr))
# add histogram of SNR values with 'SNRcut'-off drawn?
self.allowedLists[_condi] = snr.where(
snr >= self.excludeSNRcut).dropna()
self.excludedLists[_condi] = snr.where(
snr < self.excludeSNRcut).dropna()
self.allowedCount += len(self.allowedLists[_condi])
self.excludedCount += len(self.excludedLists[_condi])
#print ("allowedList: "+_condi, self.allowedLists[_condi])
#print ("excludedList: "+_condi, self.excludedLists[_condi])
#update dialog
skipLabelText = "Skipping {0} traces out of {1} for low SNR.".format(
self.excludedCount, self.allowedCount + self.excludedCount)
self.skipRB.setText(skipLabelText)
