def new_console(tabto=None, floating=False, dockingarea=QtCore.Qt.RightDockWidgetArea):
"""
Create a new console and float it as a max widget
tabto: name of a widget on top of which the console should be tabbed
floating: True to float the console, False to leave it docked
dockingarea: The docking area for docking the window (default = right)
"""
main_window = GetQMaxMainWindow()
# create and setup a console
console = PythonConsole(formats=HUGOS_THEME)
console.setStyleSheet("background-color: #333333;")
# create a dock widget for the console
dock_widget = QDockWidget(main_window)
dock_widget.setWidget(console)
dock_widget.setObjectName("pyconsole")
dock_widget.setWindowTitle("Python Console")
main_window.addDockWidget(dockingarea, dock_widget)
if not tabto is None:
tabw = main_window.findChild(QWidget, tabto)
main_window.tabifyDockWidget(tabw, dock_widget)
dock_widget.setFloating(floating)
dock_widget.show()
# make the console do stuff
console.eval_queued()
return console
def _move_dock_to_new_parent(self,
dock: QDockWidget,
new_parent: QMainWindow,
dock_location=Qt.BottomDockWidgetArea):
"""The the doc to a different parent window.
Args:
dock (QDockWidget): Dock to move
new_parent (QMainWindow): New parent window
dock_location (Qt dock location): Location of the dock. Defaults to Qt.BottomDockWidgetArea.
"""
dock.setParent(new_parent)
new_parent.addDockWidget(dock_location, dock)
dock.setFloating(False)
dock.show()
dock.setMaximumHeight(99999)
def demo_docking_widgets():
"""
Demonstrates how to create a QWidget with PySide2 and attach it to the 3dsmax main window.
Creates two types of dockable widgets, a QDockWidget and a QToolbar
"""
# Retrieve 3ds Max Main Window QWdiget
main_window = GetQMaxMainWindow()
# QAction reused by both dockable widgets.
cylinder_icon_path = os.path.dirname(os.path.realpath(__file__)) + "\\cylinder_icon_48.png"
cylinder_icon = QtGui.QIcon(cylinder_icon_path)
create_cyl_action = QAction(cylinder_icon, u"Create Cylinder", main_window)
create_cyl_action.triggered.connect(create_cylinder)
# QDockWidget construction and placement over the main window
dock_widget = QDockWidget(main_window)
# Set for position persistence
dock_widget.setObjectName("Creators")
# Set to see dock widget name in toolbar customize popup
dock_widget.setWindowTitle("Creators")
dock_tool_button = QToolButton()
dock_tool_button.setAutoRaise(True)
dock_tool_button.setDefaultAction(create_cyl_action)
dock_tool_button.setToolButtonStyle(QtCore.Qt.ToolButtonTextOnly)
dock_widget.setWidget(dock_tool_button)
main_window.addDockWidget(QtCore.Qt.LeftDockWidgetArea, dock_widget)
dock_widget.setFloating(True)
dock_widget.show()
# QToolBar construction and attachement to main window
toolbar_widget = QToolBar(main_window)
# Set for position persistence
toolbar_widget.setObjectName("Creators TB")
# Set to see dock widget name in toolbar customize popup
toolbar_widget.setWindowTitle("Creators TB")
toolbar_widget.setFloatable(True)
toolbar_widget.addAction(create_cyl_action)
main_window.addToolBar(QtCore.Qt.BottomToolBarArea, toolbar_widget)
toolbar_widget.show()
toolbar_position = get_pos_to_dock_toolbar(dock_widget)
make_toolbar_floating(toolbar_widget, toolbar_position)
def __init__(self):
super().__init__()
# SET => App Icon
self.icon = QIcon("img/iconXLNK.png")
# End
self.tree_view = None
self.file_system_model = None
# SET => Window Icon
self.setWindowIcon(self.icon)
# End
# WSET => Window Title
self.setWindowTitle("XLNK | Data Manager")
# End
# Menus
self.menu = self.menuBar()
self.file_menu = self.menu.addMenu("&File")
self.edit_menu = self.menu.addMenu("&Edit")
self.view_menu = self.menu.addMenu("&View")
self.help_menu = self.menu.addMenu("&Help")
# End
# ===================
# Menu Button Actions
# Exit QAction
exit_action = QAction("Exit", self)
exit_action.setShortcut(QKeySequence.Quit)
exit_action.triggered.connect(self.close)
self.file_menu.addAction(exit_action)
# End
# End
# Tool Bar
toolbar = QToolBar(self)
self.addToolBar(toolbar)
# delete action on toolbar
delete_action_tb = QAction("DELETE TABLE ROW", self)
delete_action_tb.setStatusTip("Obrisi Red U Tabeli")
delete_action_tb.triggered.connect(self.delete_table_row_tb)
toolbar.addAction(delete_action_tb)
# Dock Widget
dock_widget = QDockWidget("EXPLORER", self)
# File System Model
self.file_system_model = QFileSystemModel()
self.file_system_model.setRootPath(QDir.currentPath())
# SET => Tree View MOdel
self.tree_view = QTreeView()
self.tree_view.setModel(self.file_system_model)
self.tree_view.setRootIndex(
self.file_system_model.index(QDir.currentPath() + "/data"))
self.tree_view.clicked.connect(self.file_clicked_handler)
dock_widget.setWidget(self.tree_view)
dock_widget.setFloating(False)
self.addDockWidget(Qt.LeftDockWidgetArea, dock_widget)
# QLabel
qlabel = QLabel(self)
qlabel.setText("Welcome to XLNK.")
# Central Widget
self.clicked_file = None
self.setCentralWidget(qlabel)
self.showMaximized()
class ListenerView(QMainWindow):
def __init__(self, *args):
super(ListenerView, self).__init__(*args)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.window_branding()
self.create_menu()
self.create_main()
self.create_status()
self.create_container_view()
self.create_audio_view()
app = property(appref.app)
def window_branding(self):
"""Setup our general branding for the window"""
self.setWindowTitle(defaults.APP_NAME_HUMAN)
self.setWindowIcon(icons.get_icon("microphone"))
def create_menu(self):
"""Create the overall application menu"""
self.menu = QMenuBar()
app = self.app
self.dictation_menu = self.menu.addMenu('&Dictation')
self.dictation_menu.addAction(app.start_listening)
self.dictation_menu.addAction(app.stop_listening)
self.dictation_menu.addAction(app.reposition_overlay)
self.setMenuBar(self.menu)
def create_main(self):
"""Create our main central widgets"""
self.mdi = QMdiArea(self)
self.setCentralWidget(self.mdi)
def create_status(self):
"""Create our listening status-bar"""
self.status_bar = QStatusBar(self)
self.setStatusBar(self.status_bar)
self.status_bar.showMessage('%s is loading...' %
(defaults.APP_NAME_HUMAN))
def create_audio_view(self):
"""Create the audio control view"""
self.audio_dock = QDockWidget("Audio", self)
self.audio_dock.setFloating(False)
self.audio_view = audioview.ListenerAudio(self)
self.audio_dock.setWidget(self.audio_view)
self.addDockWidget(
Qt.LeftDockWidgetArea,
self.audio_dock,
)
def create_container_view(self):
"""Create the container view"""
self.container_dock = QDockWidget("Container", self)
self.container_dock.setFloating(False)
self.container_view = containersettings.ContainerSettings(self)
self.container_dock.setWidget(self.container_view)
self.addDockWidget(
Qt.LeftDockWidgetArea,
self.container_dock,
)
class MainWindow(QMainWindow):
def __init__(self, tedaCommandLine):
super().__init__()
self.tedaCommandLine = tedaCommandLine
self.cmaps = ColorMaps()
self.combobox = QComboBox()
self.filename = None
self.isMousePressed = False
self.isCmdPressed = False
self.cursor_coords = CoordinatesModel()
self.scales_model = ScalesModel()
fig = Figure(figsize=(14, 10))
fig.tight_layout()
self.fits_image = FitsPlotter(figure=fig)
fig.subplots_adjust(left=0,
bottom=0.001,
right=1,
top=1,
wspace=None,
hspace=None)
self.fits_image = FitsPlotterFitsFile(figure=fig,
cmap_model=self.cmaps,
scale_model=self.scales_model)
self.central_widget = FigureCanvas(fig)
self.setCentralWidget(self.central_widget)
self.current_x_coord = 0
self.current_y_coord = 0
self.fullWidgetXcord = 0
self.fullWidgetYcord = 0
self.centralWidgetcordX = 0
self.centralWidgetcordY = 0
self.painterComponent = PainterComponent(self.fits_image)
# self.painterComponent.startMovingEvents(self.central_widget)
self.painterComponent.setCanvas(self.central_widget)
self.scanObject = ScanToolbar(self)
self.createActions()
self.createMenus()
self.createToolBars()
self.createStatusBar()
self.createDockWindows()
if not self.tedaCommandLine.ignoreSettings:
self.scaleWidget.readSlidersValues()
# self.defineButtonsActions()
self.setWindowTitle("TeDa")
self.painterComponent.observe(
lambda change: self.onAutoCenterChange(change), ['auto_center'])
self.readWindowSettings()
self.readAppState()
self.updateHeaderData()
self.dragging = draggingComponent.Dragging(
widget=self, scale_widget=self.scaleWidget)
self.activeLinearAdjustmentByMouseMovement()
# Observing here may be to late for values loaded from settings e.g. via readAppState
self.painterComponent.observe(
lambda change: self.onCenterCircleChange(change),
['ccenter_x', 'ccenter_y'])
self.painterComponent.observe(
lambda change: self.onCenterCircleRadiusChange(change),
['cradius'])
self.fits_image.observe(lambda change: self.onMouseMoveOnImage(change),
['mouse_xdata', 'mouse_ydata'])
# self.cmaps.observe(lambda change: self.on_colormap_change(change))
self.full_view_widget.painterComponent.observe(
lambda change: self.onRectangleInWidgetMove(change),
['viewX', 'viewY'])
self.painterComponent.observe(
lambda change: self.movingCentralWidget(change),
['movingViewX', 'movingViewY'])
self.fits_image.observe(lambda change: self.onMouseZoomOnImage(change),
['viewBounaries_versionno'])
# open last fits
try:
self.openLastFits()
except FileNotFoundError:
print('Błąd w odczycie lub brak ostatio wczytanego pliku')
def closeEvent(self, event: PySide2.QtGui.QCloseEvent):
self.writeAppState()
self.writeWindowSettings()
if not self.tedaCommandLine.ignoreSettings:
self.scaleWidget.writeSlidersValues()
super().closeEvent(event)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Delete:
self.deleteSelected()
if e.key() == Qt.Key_R:
action = self.dockRadialFit.toggleViewAction()
if not action.isChecked():
action.trigger()
if (self.cursor_coords.img_x != 0 and self.cursor_coords.img_x !=
None) and (self.cursor_coords.img_y != 0
and self.cursor_coords.img_y != None):
self.painterComponent.add(self.cursor_coords.img_x,
self.cursor_coords.img_y,
type="circleCenter")
self.painterComponent.paintAllShapes(
self.central_widget.figure.axes[0])
if e.key() == Qt.Key_Control:
self.isCmdPressed = True
def keyReleaseEvent(self, event: PySide2.QtGui.QKeyEvent):
if event.key() == Qt.Key_Control:
self.isCmdPressed = False
def canvasMousePressEvent(self, event):
self.isMousePressed = not self.isMousePressed
def mouseMoveEventOnCanvas(self, event):
if self.isCmdPressed:
if self.isMousePressed:
self.dragging.mouseMoveEvent(event)
def print_(self):
document = self.textEdit.document()
printer = QPrinter()
dlg = QPrintDialog(printer, self)
if dlg.exec_() != QDialog.Accepted:
return
document.print_(printer)
self.statusBar().showMessage("Ready", 2000)
def open_dialog(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Image", ".",
"Fits files (*.fits)")
if fileName:
self.open_fits(fileName)
def save(self):
filename, _ = QFileDialog.getSaveFileName(self, "Choose a file name",
'.', "HTML (*.html *.htm)")
if not filename:
return
file = QFile(filename)
if not file.open(QFile.WriteOnly | QFile.Text):
QMessageBox.warning(
self, "Dock Widgets",
"Cannot write file %s:\n%s." % (filename, file.errorString()))
return
out = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
out << self.textEdit.toHtml()
QApplication.restoreOverrideCursor()
self.statusBar().showMessage("Saved '%s'" % filename, 2000)
def save_dialog(self):
figure = self.central_widget.figure
filetypes = figure.canvas.get_supported_filetypes_grouped()
filterstr = ';;'.join([
k + ' (' + ' '.join(['*.' + ext for ext in v]) + ')'
for k, v in filetypes.items()
])
dialog = QFileDialog.getSaveFileName(
self, "Save Image As...",
os.path.splitext(self.filename)[0], filterstr)
if dialog[0] != "":
try:
self.central_widget.figure.savefig(dialog[0])
except ValueError:
print("Unsupported format")
def open_fits(self, fileName):
"""Opens specified FITS file and loads it to user interface"""
self.fits_image.set_file(fileName)
self.filename = fileName
self.cursor_coords.set_wcs_from_fits(
self.fits_image.header
) # TODO: one up and extract and set wcs in fits_image before plot
self.fits_image.set_wcs(self.cursor_coords.wcs)
self.fits_image.plot()
self.radial_profile_widget.set_data(self.fits_image.data)
self.radial_profile_iraf_widget.set_data(self.fits_image.data)
self.updateHeaderData()
self.zoom_view_widget.updateFits(self.fits_image)
self.full_view_widget.updateFits(self.fits_image)
self.saveLastFits()
def saveLastFits(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("Files")
settings.setValue("lastFile", self.filename)
settings.endGroup()
def openLastFits(self):
if (self.tedaCommandLine.openFile is None):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("Files")
filename = settings.value("lastFile")
settings.endGroup()
else:
filename = self.tedaCommandLine.openFile
if filename:
self.open_fits(filename)
def readAppState(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("WCS")
self.wcsSexAct.setChecked(bool(settings.value("sexagesimal", True)))
self.wcsGridAct.setChecked(bool(settings.value("grid", False)))
settings.endGroup()
settings.beginGroup("paint")
self.painterComponent.auto_center = bool(
settings.value("auto_center", True))
settings.endGroup()
def writeAppState(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("WCS")
settings.setValue("sexagesimal", self.wcsSexAct.isChecked())
settings.setValue("grid", self.wcsGridAct.isChecked())
settings.endGroup()
settings.beginGroup("paint")
settings.setValue("auto_center", self.painterComponent.auto_center)
settings.endGroup()
def undo(self):
document = self.textEdit.document()
document.undo()
def insertCustomer(self, customer):
if not customer:
return
def addParagraph(self, paragraph):
if not paragraph:
return
def about(self):
QMessageBox.about(
self, "TeDa FITS Viewer", f"TeDa FITS Viewer {__version__} <br/>"
"Authors: <ul> "
"<li>Michał Brodniak</li>"
"<li>Konrad Górski</li>"
"<li>Mikołaj Kałuszyński</li>"
"<li>Edward Lis</li>"
"<li>Grzegorz Mroczkowski</li>"
"</ul>"
"Created by <a href='https://akond.com'>Akond Lab</a> for The "
"<a href='https://araucaria.camk.edu.pl'>Araucaria Project</a><br/>"
"Licence: MIT <br/>"
"3rd party work used: "
"<a href='https://material.io/resources/icons/'> Google Material Icons</a>, "
"<a href='https://www.astropy.org'> AstroPy</a>, "
"<a href='https://doc.qt.io/qtforpython/'> Qt5/PySide2</a>, "
"<a href='https://www.scipy.org'> SciPy</a>, and other..."
"<br/><br/>"
"Visit the <a href='https://github.com/majkelx/teda'>project's GitHub page</a> for help"
" and the issue tracker")
def on_console_show(self):
console.show(ax=self.fits_image.ax,
window=self,
data=self.fits_image.data,
header=self.fits_image.header,
wcs=self.cursor_coords.wcs)
def on_sex_toggle(self):
print('sex toggled to :', self.wcsSexAct.isChecked())
self.cursor_coords.wcs_sexagesimal = self.wcsSexAct.isChecked()
def on_grid_toggle(self):
self.fits_image.plot_grid = self.wcsGridAct.isChecked()
def createActions(self):
# ico1 = QPixmap('/Users/mka/projects/astro/teda/icons/png.png')
# self.openAct = QAction(ico1, "&Open", self, shortcut=QKeySequence.Open, statusTip="Open FITS file", triggered=self.open)
self.openAct = QAction(IconFactory.getIcon('note_add'),
"&Open",
self,
shortcut=QKeySequence.Open,
statusTip="Open FITS file",
triggered=self.open_dialog)
self.saveAct = QAction(IconFactory.getIcon('save'),
"&Save",
self,
shortcut=QKeySequence.Save,
statusTip="Save FITS view",
triggered=self.save_dialog)
self.quitAct = QAction("&Quit",
self,
shortcut="Ctrl+Q",
statusTip="Quit the application",
triggered=self.close)
self.aboutAct = QAction("&About",
self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt",
self,
statusTip="Show the Qt library's About box",
triggered=QApplication.instance().aboutQt)
self.qtConsoleAct = QAction('Python Console',
self,
statusTip="Open IPython console window",
triggered=self.on_console_show)
self.wcsSexAct = QAction(
'Sexagesimal',
self,
statusTip=
"Format WCS coordinates as sexagesimal (RA in hour angle) instead of decimal deg"
)
self.wcsSexAct.toggled.connect(self.on_sex_toggle)
self.wcsSexAct.setCheckable(True)
self.wcsGridAct = QAction(
'Show Grid',
self,
statusTip="Overlay WCS coordinates grid over image",
)
self.wcsGridAct.setCheckable(True)
self.wcsGridAct.toggled.connect(self.on_grid_toggle)
self.prevHDUAct = QAction(IconFactory.getIcon('skip_previous'),
'Prev HDU',
self,
statusTip="Previous HDU",
triggered=self.prevHDU)
self.nextHDUAct = QAction(IconFactory.getIcon('skip_next'),
'Next HDU',
self,
statusTip="Next HDU",
triggered=self.nextHDU)
self.zoom4Act = QAction(IconFactory.getIcon("x4"),
'Zoom ×4',
self,
statusTip="Zoom ×4",
triggered=self.setZoomButton4)
self.zoom2Act = QAction(IconFactory.getIcon("x2"),
'Zoom ×2',
self,
statusTip="Zoom ×2",
triggered=self.setZoomButton2)
self.zoomHomeAct = QAction(IconFactory.getIcon('home'),
'Home',
self,
statusTip="Reset zoom an position",
triggered=self.setZoomButtonHome)
self.zoom05Act = QAction(IconFactory.getIcon("1-2"),
'Zoom 1/2',
self,
statusTip="Zoom 1/2",
triggered=self.setZoomButton05)
self.zoom025Act = QAction(IconFactory.getIcon("1-4"),
'Zoom 1/4',
self,
statusTip="Zoom 1/4",
triggered=self.setZoomButton025)
self.panningAct = QAction(IconFactory.getIcon('panning'),
'Panning',
self,
statusTip="Panning",
triggered=self.changePanningStatus)
self.circleAct = QAction(IconFactory.getIcon('circle'),
'Add Region',
self,
statusTip="Add Region",
triggered=self.changeAddCircleStatus)
self.centerCircleAct = QAction(
IconFactory.getIcon('add_circle_outline'),
'Radial profile',
self,
statusTip="Radial profile with gaussoide fit [R]-key",
triggered=self.changeAddCenterCircleStatus)
self.autoCenterAct = QAction(
'Auto Center',
self,
statusTip="Automatically center cursor on star centroid",
triggered=self.changeAutoCenter)
self.deleteAct = QAction(IconFactory.getIcon('delete_forever'),
'Delete selected',
self,
statusTip="Delete selected [Del]-key",
triggered=self.deleteSelected)
self.slidersAct = QAction(
IconFactory.getIcon('slider'),
'Dynamic Scale Sliders',
self,
statusTip='Show/Hide Dynamic Scale',
triggered=self.dynamicScaleDockWidgetTriggerActions)
self.panningAct.setCheckable(True)
self.panningAct.setChecked(True)
self.circleAct.setCheckable(True)
self.autoCenterAct.setCheckable(True)
self.autoCenterAct.setChecked(self.painterComponent.auto_center)
self.centerCircleAct.setCheckable(True)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.scanObject.scanAct)
self.fileMenu.addAction(self.scanObject.stopAct)
self.fileMenu.addAction(self.scanObject.pauseAct)
self.fileMenu.addAction(self.scanObject.resumeAct)
self.fileMenu.addAction(self.scanObject.autopauseAct)
self.fileMenu.addAction(self.scanObject.disabledautopauseAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.quitAct)
self.editMenu = self.menuBar().addMenu("&Edit")
self.editMenu.addAction(self.panningAct)
self.editMenu.addAction(self.circleAct)
self.editMenu.addAction(self.centerCircleAct)
self.editMenu.addSeparator()
self.editMenu.addAction(self.autoCenterAct)
self.editMenu.addSeparator()
self.editMenu.addAction(self.deleteAct)
self.hduMenu = self.menuBar().addMenu("HDU")
self.hduMenu.addAction(self.prevHDUAct)
self.hduMenu.addAction(self.nextHDUAct)
self.hduMenu.addSeparator()
self.zoomMenu = self.menuBar().addMenu("Zoom")
self.zoomMenu.addAction(self.zoom4Act)
self.zoomMenu.addAction(self.zoom2Act)
self.zoomMenu.addAction(self.zoomHomeAct)
self.zoomMenu.addAction(self.zoom05Act)
self.zoomMenu.addAction(self.zoom025Act)
self.WcsMenu = self.menuBar().addMenu("W&CS")
self.WcsMenu.addAction(self.wcsSexAct)
self.WcsMenu.addSeparator()
self.WcsMenu.addAction(self.wcsGridAct)
self.viewMenu = self.menuBar().addMenu("&View")
self.viewMenu.addAction(self.qtConsoleAct)
self.viewMenu.addSeparator()
self.menuBar().addSeparator()
self.helpMenu = self.menuBar().addMenu("&Help")
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
def createToolBars(self):
self.fileToolBar = self.addToolBar("File Toolbar")
self.fileToolBar.addAction(self.openAct)
self.fileToolBar.addAction(self.saveAct)
self.hduToolBar = self.addToolBar("HDU Toolbar")
self.hduToolBar.addAction(self.prevHDUAct)
self.hduToolBar.addAction(self.nextHDUAct)
self.scanToolBar = self.addToolBar("Scan Toolbar")
self.scanToolBar.addAction(self.scanObject.scanAct)
self.scanToolBar.addAction(self.scanObject.stopAct)
self.scanToolBar.addAction(self.scanObject.pauseAct)
self.scanToolBar.addAction(self.scanObject.resumeAct)
self.scanToolBar.addAction(self.scanObject.autopauseAct)
self.scanToolBar.addAction(self.scanObject.disabledautopauseAct)
self.scanToolBar.hide()
# self.infoToolBar = self.addToolBar("Info Toolbar")
# self.mouse_x_label = QLabel('100.1')
# self.mouse_y_label = QLabel('100.145')
# self.infoToolBar.addWidget(QLabel('image x:'))
# self.infoToolBar.addWidget(self.mouse_x_label)
# self.infoToolBar.addWidget(QLabel('y:'))
# self.infoToolBar.addWidget(self.mouse_y_label)
# self.infoToolBar.hide()
self.zoomToolBar = self.addToolBar("Zoom Toolbar")
self.zoomToolBar.addAction(self.zoom4Act)
self.zoomToolBar.addAction(self.zoom2Act)
self.zoomToolBar.addAction(self.zoomHomeAct)
self.zoomToolBar.addAction(self.zoom05Act)
self.zoomToolBar.addAction(self.zoom025Act)
self.mouseActionToolBar = self.addToolBar("Mouse Task Toolbar")
self.mouseActionToolBar.addAction(self.panningAct)
self.mouseActionToolBar.addAction(self.circleAct)
self.mouseActionToolBar.addAction(self.centerCircleAct)
self.mouseActionToolBar.addAction(self.deleteAct)
self.sliderToolBar = self.addToolBar("Slider Toolbar")
self.slidersAct.setChecked(True)
self.sliderToolBar.addAction(self.slidersAct)
self.viewMenu.addAction(self.fileToolBar.toggleViewAction())
self.viewMenu.addAction(self.hduToolBar.toggleViewAction())
self.viewMenu.addAction(self.scanToolBar.toggleViewAction())
# self.viewMenu.addAction(self.infoToolBar.toggleViewAction())
self.viewMenu.addAction(self.zoomToolBar.toggleViewAction())
self.viewMenu.addAction(self.mouseActionToolBar.toggleViewAction())
self.viewMenu.addAction(self.sliderToolBar.toggleViewAction())
self.viewMenu.addSeparator()
def nextHDU(self):
self.fits_image.changeHDU(True, 1)
self.updateHeaderData()
def prevHDU(self):
self.fits_image.changeHDU(True, -1)
self.updateHeaderData()
def updateHeaderData(self):
self.headerWidget.setHeader()
self.prevHDUAct.setEnabled(self.fits_image._huds is not None
and self.fits_image.hdu != 0)
self.nextHDUAct.setEnabled(
self.fits_image._huds is not None
and self.fits_image.hdu != len(self.fits_image._huds) - 1)
def setZoomButton4(self):
self.setZoomButton(4, False)
def setZoomButton2(self):
self.setZoomButton(2, False)
def setZoomButtonHome(self):
self.setZoomButton(1, True)
def setZoomButton05(self):
self.setZoomButton(0.5, False)
def setZoomButton025(self):
self.setZoomButton(0.25, False)
def setZoomButton(self, zoom: float, reset: bool):
if self.fits_image.ax != None:
self.fits_image.setZoom(zoom, reset)
self.full_view_widget.updateMiniatureShape(self.fits_image.viewX,
self.fits_image.viewY,
self.fits_image.viewW,
self.fits_image.viewH)
def changePanningStatus(self):
if self.panningAct.isChecked():
self.toogleOffRegionButtons()
self.panningAct.toggle()
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.startMovingEvents(self.central_widget)
else:
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.stopMovingEvents(self.central_widget)
def changeAddCircleStatus(self):
if self.circleAct.isChecked():
self.toogleOffRegionButtons()
self.circleAct.toggle()
self.painterComponent.startPainting(self.central_widget, "circle")
else:
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.startMovingEvents(self.central_widget)
self.panningAct.toggle()
def changeAddCenterCircleStatus(self):
if self.centerCircleAct.isChecked():
self.toogleOffRegionButtons()
self.centerCircleAct.toggle()
self.painterComponent.startPainting(self.central_widget,
"circleCenter")
else:
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.startMovingEvents(self.central_widget)
self.panningAct.toggle()
def changeAutoCenter(self):
self.painterComponent.auto_center = self.autoCenterAct.isChecked()
def deleteSelected(self):
self.painterComponent.deleteSelectedShapes(
self.central_widget.figure.axes[0])
def toogleOffRegionButtons(self):
if self.panningAct.isChecked():
self.panningAct.toggle()
if self.circleAct.isChecked():
self.circleAct.toggle()
if self.centerCircleAct.isChecked():
self.centerCircleAct.toggle()
self.painterComponent.stopPainting(self.central_widget)
def createStatusBar(self):
self.statusBar().showMessage("Ready")
def createDockWindows(self):
# Scale
self.dynamic_scale_dock = QDockWidget("Dynamic Scale", self)
self.dynamic_scale_dock.setObjectName("SCALE")
self.dynamic_scale_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.scaleWidget = ScaleWidget(self,
scales_model=self.scales_model,
cmap_model=self.cmaps)
self.dynamic_scale_dock.setWidget(self.scaleWidget)
self.addDockWidget(Qt.RightDockWidgetArea, self.dynamic_scale_dock)
self.viewMenu.addAction(self.dynamic_scale_dock.toggleViewAction())
self.dynamic_scale_dock.setFloating(True)
self.dynamic_scale_dock.hide()
#radial profiles
dock = QDockWidget("Radial Profile Fit", self)
dock.setObjectName("RADIAL_PROFILE_IRAF")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.radial_profile_iraf_widget = IRAFRadialProfileWidget(
self.fits_image.data)
dock.setWidget(self.radial_profile_iraf_widget)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.dockRadialFit = dock
dock = QDockWidget("Radial Profile Curve", self)
dock.setObjectName("RADIAL_PROFILE")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.radial_profile_widget = RadialProfileWidget(self.fits_image.data)
dock.setWidget(self.radial_profile_widget)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
dock.hide()
#info panel
dock = QDockWidget("Info", self)
dock.setObjectName("INFO_PANEL")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.info_widget = InfoWidget(self)
dock.setWidget(self.info_widget)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
# FITS headers
dock = QDockWidget("FITS header", self)
dock.setObjectName("FTIS_DATA")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.headerWidget = HeaderTableWidget(self)
self.headerWidget.setColumnCount(2)
self.headerWidget.setHorizontalHeaderItem(0, QTableWidgetItem("KEY"))
self.headerWidget.setHorizontalHeaderItem(1, QTableWidgetItem("VALUE"))
self.headerWidget.horizontalHeader().setStretchLastSection(1)
self.headerWidget.setEditTriggers(
QtWidgets.QTableWidget.NoEditTriggers)
self.headerWidget.clearFocus()
dock.setWidget(self.headerWidget)
# full
dock = QDockWidget("Full view", self)
dock.setObjectName("FULL_VIEW")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.full_view_widget = FullViewWidget(self.fits_image)
self.full_view_widget.fits_image.set_scale_model(self.scales_model)
self.full_view_widget.fits_image.set_cmap_model(self.cmaps)
dock.setWidget(self.full_view_widget)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
# zoom
dock = QDockWidget("Zoom view", self)
dock.setObjectName("ZOOM_VIEW")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.zoom_view_widget = ZoomViewWidget(self.fits_image)
self.zoom_view_widget.fits_image.set_scale_model(self.scales_model)
self.zoom_view_widget.fits_image.set_cmap_model(self.cmaps)
dock.setWidget(self.zoom_view_widget)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
# fileSelector
dock = QDockWidget("Directory view", self)
dock.setObjectName("DIRECTORY_VIEW")
dock.setAllowedAreas(Qt.LeftDockWidgetArea)
self.file_widget = FileSystemWidget(self)
dock.setWidget(self.file_widget)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.viewMenu.addSeparator()
# def changeColor(self, color):
# self.cmaps.set_active_color_map(color)
# def on_colormap_change(self, change):
# self.fits_image.cmap = self.cmaps.get_active_color_map()
# self.fits_image.plot()
# self.updateFitsInWidgets()
def onAutoCenterChange(self, change):
self.autoCenterAct.setChecked(change.new)
def dynamicScaleDockWidgetTriggerActions(self):
if self.dynamic_scale_dock.isHidden():
self.dynamic_scale_dock.show()
else:
self.dynamic_scale_dock.hide()
def onCenterCircleChange(self, change):
self.radial_profile_widget.set_centroid(
self.painterComponent.ccenter_x, self.painterComponent.ccenter_y)
self.radial_profile_iraf_widget.set_centroid(
self.painterComponent.ccenter_x, self.painterComponent.ccenter_y)
def onCenterCircleRadiusChange(self, change):
self.radial_profile_widget.set_radius(self.painterComponent.cradius)
self.radial_profile_iraf_widget.set_radius(
self.painterComponent.cradius)
def onRectangleInWidgetMove(self, change):
changed = False
if change.new is not None:
changed = True
if change.name == 'viewX':
self.fullWidgetXcord = change.new
elif change.name == 'viewY':
self.fullWidgetYcord = change.new
if changed:
self.fits_image.moveToXYcords(self.fullWidgetXcord,
self.fullWidgetYcord)
def movingCentralWidget(self, change):
changed = False
if change.new is not None:
changed = True
if change.name == 'movingViewX':
self.centralWidgetcordX = change.new
elif change.name == 'movingViewY':
self.centralWidgetcordY = change.new
if changed:
self.full_view_widget.updateMiniatureShapeXYonly(
self.centralWidgetcordX, self.centralWidgetcordY)
def onMouseMoveOnImage(self, change):
display = ''
val = 0
if change.new is not None:
display = f'{change.new:f}'
val = change.new
if change.name == 'mouse_xdata':
# self.mouse_x_label.setText(display)
self.current_x_coord = val
self.cursor_coords.set_img_x(change.new)
elif change.name == 'mouse_ydata':
# self.mouse_y_label.setText(display)
self.current_y_coord = val
self.cursor_coords.set_img_y(change.new)
if display != '':
self.zoom_view_widget.setXYofZoom(self.fits_image,
self.current_x_coord,
self.current_y_coord,
self.fits_image.zoom)
if not self.hasFocus():
self.setFocus()
if self.scanObject.activeScan and self.scanObject.enableAutopause: #reser autopause
if not self.scanObject.obserwableValue.autopauseFlag:
self.scanObject.obserwableValue.autopauseFlag = True
def activeLinearAdjustmentByMouseMovement(self):
self.central_widget.mpl_connect('motion_notify_event',
self.mouseMoveEventOnCanvas)
self.central_widget.mpl_connect('button_press_event',
self.canvasMousePressEvent)
self.central_widget.mpl_connect('button_release_event',
self.canvasMousePressEvent)
def onMouseZoomOnImage(self, change):
changed = False
if change.new is not None:
changed = True
if changed:
self.full_view_widget.updateMiniatureShape(self.fits_image.viewX,
self.fits_image.viewY,
self.fits_image.viewW,
self.fits_image.viewH)
def readWindowSettings(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("MainWindow")
size, pos = settings.value("size"), settings.value("pos")
settings.endGroup()
if size is not None and pos is not None:
print('settings: resize to {} and move to {}', size, pos)
self.move(pos)
# self.resize(size)
print('Size reported ', self.size())
print('Size set ', size)
self.resize(size)
print('Size reported ', self.size())
else:
self.resize(800, 600)
geometry = settings.value("geometry")
if geometry is not None:
self.restoreGeometry(geometry)
self.restoreState(settings.value("windowState"))
self.headerWidget.readSettings(settings)
self.file_widget.readSettings(settings)
def writeWindowSettings(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("MainWindow")
settings.setValue("size", self.size())
settings.setValue("pos", self.pos())
settings.endGroup()
settings.setValue('geometry', self.saveGeometry())
settings.setValue('windowState', self.saveState())
self.headerWidget.writeSettings(settings)
self.file_widget.writeSettings(settings)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
# super().__init__()
QMainWindow.__init__(self, parent)
# const value
self.dequeMax = 1000
self.notchCutOff = 60
self.notchQualityFactor = 15
self.lowPassCutOff = 50
self.lowPassOrder = 8
self.samplingRate = 500
self.two_16 = pow(2, 16)
self.two_8 = pow(2, 8)
self.max_uv = 407
self.two_resolution = 8388607
self.rawGraphFrame = 25
self.update_num = 20
self.timerCounter = 0
# value
self.measure_time = 0
self.timerCount = 0
self.printIndex = 0
self.headerCount = 0
self.ch1_1_value = 0
self.ch1_2_value = 0
self.ch1_3_value = 0
self.ch2_1_value = 0
self.ch2_2_value = 0
self.ch2_3_value = 0
self.dataIndex = 0
self.read_state = parsingState.header1
self.ptr = 0
self.ptrFilter = 0
self.ptrTime = 0
self.boolPaused = True
# UI
self.pgWidget = QWidget()
self.setCentralWidget(self.pgWidget)
self.setGeometry(QRect(250, 120, 1600, 820))
self.dockingWidget = QDockWidget("개발용 텍스트")
self.listWidget = QListWidget()
self.listWidget.setFont("Courier")
self.dockingWidget.setWidget(self.listWidget)
self.dockingWidget.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.dockingWidget.setFloating(False)
self.addDockWidget(Qt.RightDockWidgetArea, self.dockingWidget)
self.vBoxLayout2 = QVBoxLayout(self.pgWidget)
self.lLabel = QLabel("블루투스 자동연결을 실행합니다.")
self.lLabel.resize(200, 45)
self.lLabel.setMaximumHeight(45)
self.lLabel.setMinimumHeight(30)
self.lLabel.setStyleSheet("color: blue;"
"border-style: solid;"
"border-width: 1px;"
"border-color: #c1f7fe;"
"border-radius: 3px;"
"background-color: #F7FFFE;")
font1 = self.lLabel.font()
font1.setPointSize(30)
font1.setFamily('Times New Roman')
font1.setBold(True)
self.lLabel.setFont(font1)
self.setWindowTitle('Brint Monitor')
self.setWindowIcon(QIcon("./images/brainGreen.png"))
# grpah
self.ax3 = pg.PlotWidget()
self.ax3.setMaximumHeight(340)
self.ax3.setMinimumHeight(250)
self.ax3.setDownsampling(mode='peak')
self.ax3.setTitle("좌측 뇌파", color='w')
self.ax3.setClipToView(True)
self.ax3.setLabel('left', "뇌파 [uV]", color='white')
self.ax3.setLabel('bottom', '시간 [초]', color='white')
self.ax3.setRange(xRange=[-10, 0], yRange=[-150, 150])
self.ax4 = pg.PlotWidget()
self.ax4.setMaximumHeight(340)
self.ax4.setMinimumHeight(250)
self.ax4.setDownsampling(mode='peak')
self.ax4.setTitle("우측 뇌파", color='w')
self.ax4.setClipToView(True)
self.ax4.setRange(xRange=[-10, 0], yRange=[-150, 150])
self.ax4.setLabel('left', '뇌파 [uV]', color='white')
self.ax4.setLabel('bottom', '시간 [초]', color='white', size=30)
self.vBoxLayout2.addWidget(self.ax3)
self.vBoxLayout2.addWidget(self.ax4)
self.pen = pg.mkPen(color=(255, 0, 0))
self.line3 = self.ax3.plot(pen=self.pen)
self.line4 = self.ax4.plot()
self.data3 = np.zeros(500)
self.data3_x = np.linspace(0, 499, 500) * 0.002
self.data4 = np.zeros(500)
self.data4_x = np.linspace(0, 499, 500) * 0.002
self.vBoxLayout2.addWidget(self.lLabel)
# database
self.fData = deque(np.zeros(self.dequeMax), maxlen=self.dequeMax)
self.fData2 = deque(np.zeros(self.dequeMax), maxlen=self.dequeMax)
self.buffer = []
self.ch1_int_buffer = []
self.ch2_int_buffer = []
# xml
self.user = ET.Element("userName")
# bluetooth
self.scanner = BleakScanner()
self.macAddress = " "
self.Read_UUID = "0000fff1-0000-1000-8000-00805f9b34fb"
self.Rx_UUID = "a9da6040-0823-4995-94ec-9ce41ca28833"
self.Tx_UUID = "a73e9a10-628f-4494-a099-12efaf72258f"
self.client = None
# "74:F0:7D:C0:52:0C"
self.panaxAddress = "PAPA" # "BGX-76DE"
self.find_device = False
self.noexcept = False
self.conBool = False
self.autoScan()
# event
# create actions, file menu action
self.save = QAction("&Save", self)
self.save.setIcon(QIcon("./images/saveBlue.png"))
self.save.setShortcut("Ctrl+S")
self.save.setStatusTip("Save .xml file")
self.save.triggered.connect(self.save_rx)
self.exitAction = QAction("E&xit", self)
self.exitAction.setIcon(QIcon("./images/Quit.png"))
self.exitAction.setShortcut("Ctrl+Q")
self.exitAction.setStatusTip("Exit the application")
self.exitAction.triggered.connect(self.close)
# control menu action
self.start = QAction("S&tart", self)
self.start.setIcon(QIcon("./images/recordRed.png"))
self.start.setStatusTip("측정을 시작합니다")
self.start.triggered.connect(self.startDialog)
self.paused = QAction("P&ause", self)
self.paused.setIcon(QIcon("./images/pauseBlue.png"))
self.paused.setStatusTip("측정을 정지합니다")
self.paused.triggered.connect(self.pausedMeasure)
self.stop = QAction("&Stop", self)
self.stop.setIcon(QIcon("./images/stopBlue.png"))
self.stop.setStatusTip("측정을 멈춤니다")
self.stop.triggered.connect(self.rx_stop)
# view menu action
# about
self.aboutAction = QAction("&About", self)
self.aboutAction.setStatusTip("Show the application's About box")
self.aboutAction.triggered.connect(self.about)
# createMenus
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(self.save)
# fileMenu.addAction(self.load)
fileMenu.addAction(self.exitAction)
ControlMenu = self.menuBar().addMenu("&Control")
ControlMenu.addAction(self.start)
ControlMenu.addAction(self.paused)
ControlMenu.addAction(self.stop)
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction(self.aboutAction)
# createToolBar
pgToolBar = self.addToolBar("&PG")
pgToolBar.setObjectName("PGToolBar")
pgToolBar.addAction(self.save)
pgToolBar.addSeparator()
pgToolBar.addAction(self.start)
pgToolBar.addAction(self.paused)
pgToolBar.addAction(self.stop)
pgToolBar.addSeparator()
pgToolBar.addAction(self.aboutAction)
pgToolBar2 = self.addToolBar("PG2")
pgToolBar2.setObjectName("PGToolBar2")
# createStatusBar
'''
lLabel = QLabel("status bar")
#lLabel.setAlignment(Qt.AlignHCenter)
#lLabel.setMinimumSize(lLabel.sizeHint())
self.locationLabel = QLabel("test")
self.locationLabel.setMinimumWidth(100)
self.statusBar().setMinimumHeight(50)
self.statusBar().addWidget(lLabel)
self.statusBar().addWidget(self.locationLabel)
'''
def readSettings(self):
settings = QSettings("Panaxtos", "newneuroSpec_Demo") # modify
self.restoreGeometry(settings.value("geometry"))
self.restoreState(settings.value("state"))
def writeSettings(self):
settings = QSettings("Qt5Programming Inc.", "Shape")
self.saveGeometry()
settings.setValue("geometry", self.saveGeometry())
settings.setValue("state", self.saveState())
def autoScan(self):
asyncio.ensure_future(self.scan_start(), loop=loop)
print('btnCallback returns...')
def detection_callback(*args):
print(args)
async def scan_start(self):
self.scanner.register_detection_callback(self.detection_callback)
self.lLabel.setText("PANAXTOS 기기를 Scan 중....")
run_time = 0
start_time = time()
while run_time < 16:
await self.scanner.start()
await asyncio.sleep(5.0)
await self.scanner.stop()
devices = await self.scanner.get_discovered_devices()
if not devices:
self.lLabel.setText("bluetooth를 켜주세요")
for d in devices:
if d.name == self.panaxAddress:
self.find_device = True
self.macAddress = d.address
break
if self.find_device:
print("True")
self.lLabel.setText("기기를 찾았습니다. connection을 진행합니다.")
await self.connect_panax(self.macAddress, loop)
break
end_time = time()
run_time = end_time - start_time
if not self.find_device:
self.lLabel.setText("기기가 켜져있는지 확인해주시고 프로그램을 다시 시작해주세요")
async def connect_panax(self, address, loop):
self.client = BleakClient(address, loop=loop)
while not self.noexcept:
try:
await self.client.connect()
await self.isConnected()
self.start.setEnabled(True)
self.noexcept = True
self.lLabel.setText("연결이 완료 되었습니다. 측정시작 버튼을 눌러주세요")
except Exception as e:
print(e)
self.lLabel.setText("Connection 중")
async def isConnected(self):
self.conBool = await self.client.is_connected()
async def disconnect_panax(self):
# await self.client.disconnect()
await self.client.stop_notify(self.Read_UUID)
async def start_panax(self):
if self.conBool:
await self.client.start_notify(self.Read_UUID,
self.tx_data_received)
# await self.client.start_notify(self.Rx_UUID, self.rx_data_received)
# await asyncio.sleep(0.2)
# await self.client.stop_notify(self.Rx_UUID)
# await self.client.start_notify(self.Tx_UUID, self.tx_data_received)
async def start_rx(self):
if self.conBool:
await self.client.start_notify(self.Rx_UUID, self.rx_data_received)
async def stop_rx(self):
await self.client.stop_notify(self.Read_UUID)
def measureStart(self):
asyncio.ensure_future(self.isConnected())
asyncio.ensure_future(self.start_panax(), loop=loop)
self.start.setDisabled(True)
self.save.setEnabled(True)
self.lLabel.setText("뇌파를 측정중입니다.")
# event
def save_xml(self):
xml_write.indent(self.user)
now = datetime.datetime.now()
nowDate = now.strftime('%Y-%m-%d.%H.%M')
nowXml = nowDate + '.xml'
ET.ElementTree(self.user).write(nowXml)
nowXml = "저장이 완료 되었습니다" + nowXml
self.lLabel.setText(nowXml)
def save_rx(self):
asyncio.ensure_future(self.start_rx(), loop=loop)
def rx_stop(self):
asyncio.ensure_future(self.stop_rx(), loop=loop)
def startDialog(self):
sd = startdialog.Ui_dialog(self)
if sd.exec():
self.measure_time = sd.time_info()
self.measureStart()
def stopDialog(self):
sd = stopdialog.Ui_dialog(self)
if sd.exec():
self.plotInit()
def pausedMeasure(self):
self.boolPaused = not self.boolPaused
if not self.boolPaused:
asyncio.ensure_future(self.disconnect_panax())
self.paused.setIcon(QIcon("./images/playBlue.png"))
self.paused.setStatusTip("측정을 재개합니다")
self.lLabel.setText("측정을 정지합니다.")
else:
self.measureStart()
self.paused.setIcon(QIcon("./images/pauseBlue.png"))
self.paused.setStatusTip("측정을 정지합니다")
self.lLabel.setText("측정을 재개합니다.")
def plotInit(self):
self.lLabel.setText("측정을 초기화 하였습니다. 다시 시작하려면 시작버튼을 누르시오")
if self.boolPaused:
self.pausedMeasure()
self.fData.clear()
self.fData2.clear()
self.fData.extend(np.zeros(500))
self.fData2.extend(np.zeros(500))
self.ptr = 0
self.ptrTime = 0
self.ptrFilter = 0
self.timerCount = 0
self.line3.setData(np.empty(1))
self.line4.setData(np.empty(1))
self.ax3.setRange(xRange=[-10, 0], yRange=[-150, 150])
self.ax4.setRange(xRange=[-10, 0], yRange=[-150, 150])
self.boolPaused = not self.boolPaused
self.paused.setIcon(QIcon("./images/pauseBlue.png"))
self.paused.setStatusTip("측정을 정지합니다")
self.start.setEnabled(True)
self.paused.setDisabled(True)
self.stop.setDisabled(True)
def about(self):
QMessageBox.about(
self, "About Shape", "<h2>Brint Monitor 1.0</h2>"
"<p>Copyright © 2020 Panaxtos Inc."
"<p>Shape is a small application that "
"demonstrates QAction, QMainWindow, QMenuBar, "
"QStatusBar, QToolBar, and many other ")
# data_received -> parsing -> int -> 20 -> print
def rx_data_received(self, sender, data):
print("RX {}".format(data))
def tx_data_received(self, sender, data):
data_len = len(data)
for rep in range(data_len):
self.buffer.append(data[rep])
self.print_data()
'''data_len = len(data)
for rep in range(data_len):
self.buffer.append(data[rep])
self.read_data()
if len(self.ch1_int_buffer) >= self.update_num and len(self.ch2_int_buffer) >= self.update_num:
self.print_graph()
'''
def print_data(self):
while len(self.buffer) > 0:
temp = self.buffer.pop(0)
if self.read_state == parsingState.header1:
if temp == 255:
self.read_state = parsingState.header2
elif self.read_state == parsingState.header2:
if temp == 119:
self.read_state = parsingState.header3
elif self.read_state == parsingState.header3:
self.headerCount = temp
self.read_state = parsingState.ch1_1
elif self.read_state == parsingState.ch1_1:
self.ch1_1_value = temp
self.read_state = parsingState.ch1_2
elif self.read_state == parsingState.ch1_2:
self.ch1_2_value = temp
self.read_state = parsingState.ch1_3
elif self.read_state == parsingState.ch1_3:
self.ch1_3_value = temp
self.read_state = parsingState.ch2_1
elif self.read_state == parsingState.ch2_1:
self.ch2_1_value = temp
self.read_state = parsingState.ch2_2
elif self.read_state == parsingState.ch2_2:
self.ch2_2_value = temp
self.read_state = parsingState.ch2_3
elif self.read_state == parsingState.ch2_3:
self.ch2_3_value = temp
stringFF = hex(255)
string77 = hex(119)
hCount = "0x{:02x}".format(self.headerCount)
ch1_1 = "0x{:02x}".format(self.ch1_1_value)
ch1_2 = "0x{:02x}".format(self.ch1_2_value)
ch1_3 = "0x{:02x}".format(self.ch1_3_value)
ch2_1 = "0x{:02x}".format(self.ch2_1_value)
ch2_2 = "0x{:02x}".format(self.ch2_2_value)
ch2_3 = "0x{:02x}".format(self.ch2_3_value)
ss = stringFF + " " + string77 + " " + hCount + " " + ch1_1 + " " + ch1_2 + " " + ch1_3 + " " + ch2_1 \
+ " " + ch2_2 + " " + ch2_3
self.listWidget.addItem(ss)
self.printIndex += 1
if self.printIndex > 40:
self.listWidget.takeItem(0)
self.read_state = parsingState.header1
def read_data(self):
while len(self.buffer) > 0:
temp = self.buffer.pop(0)
if self.read_state == parsingState.header1:
if temp == 255:
self.read_state = parsingState.header2
elif self.read_state == parsingState.header2:
if temp == 119:
self.read_state = parsingState.header3
elif self.read_state == parsingState.header3:
if temp == 255:
self.read_state = parsingState.ch1_1
elif self.read_state == parsingState.ch1_1:
self.ch1_1_value = temp
self.read_state = parsingState.ch1_2
elif self.read_state == parsingState.ch1_2:
self.ch1_2_value = temp
self.read_state = parsingState.ch1_3
elif self.read_state == parsingState.ch1_3:
self.ch1_3_value = temp
self.read_state = parsingState.ch2_1
elif self.read_state == parsingState.ch2_1:
self.ch2_1_value = temp
self.read_state = parsingState.ch2_2
elif self.read_state == parsingState.ch2_2:
self.ch2_2_value = temp
self.read_state = parsingState.ch2_3
elif self.read_state == parsingState.ch2_3:
self.ch2_3_value = temp
ch1_int = (self.ch1_1_value * self.two_16) + (
self.ch1_2_value * self.two_8) + self.ch1_3_value
ch1_int = tc.twos_comp(ch1_int, 24)
ch1_int = (ch1_int * self.max_uv) / self.two_resolution
self.ch1_int_buffer.append(ch1_int)
ch2_int = (self.ch2_1_value * self.two_16) + (
self.ch2_2_value * self.two_8) + self.ch2_3_value
ch2_int = tc.twos_comp(ch2_int, 24)
ch2_int = (ch2_int * self.max_uv) / self.two_resolution
self.ch2_int_buffer.append(ch2_int)
self.dataIndex += 1
data = xml_write.makeXML(self.dataIndex, ch1_int, ch2_int)
self.user.append(data)
self.read_state = parsingState.header1
def print_graph(self):
ch1 = []
ch2 = []
for rep in range(0, self.update_num):
temp = self.ch1_int_buffer.pop(0)
temp2 = self.ch2_int_buffer.pop(0)
ch1.append(temp)
ch2.append(temp2)
self.fData.extend(ch1)
self.fData2.extend(ch2)
notch_ch1 = nf.notch_filter(self.fData, self.notchCutOff,
self.samplingRate, self.notchQualityFactor)
notch_ch2 = nf.notch_filter(self.fData2, self.notchCutOff,
self.samplingRate, self.notchQualityFactor)
notch_ch1 = nf.notch_filter(notch_ch1, self.notchCutOff,
self.samplingRate, self.notchQualityFactor)
notch_ch2 = nf.notch_filter(notch_ch2, self.notchCutOff,
self.samplingRate, self.notchQualityFactor)
notchLowPass_ch1 = lf.butter_lowpass_filter(notch_ch1,
self.lowPassCutOff,
self.samplingRate,
self.lowPassOrder)
notchLowPass_ch2 = lf.butter_lowpass_filter(notch_ch2,
self.lowPassCutOff,
self.samplingRate,
self.lowPassOrder)
filtering_ch1 = lf.butter_lowpass_filter(notchLowPass_ch1,
self.lowPassCutOff,
self.samplingRate,
self.lowPassOrder)
filtering_ch2 = lf.butter_lowpass_filter(notchLowPass_ch2,
self.lowPassCutOff,
self.samplingRate,
self.lowPassOrder)
# self.fData3.extend(filtering_ch1[-self.update_num:])
# self.fData4.extend(filtering_ch2[-self.update_num:])
self.data3[self.ptrFilter:self.ptrFilter +
self.update_num] = filtering_ch1[-self.update_num:]
self.data4[self.ptrFilter:self.ptrFilter +
self.update_num] = filtering_ch2[-self.update_num:]
self.ptrFilter += self.update_num
if self.ptrFilter >= self.data3.shape[0]:
tmp = self.data3
tmp2 = self.data4
self.data3 = np.zeros(self.data3.shape[0] * 2)
self.data4 = np.zeros(self.data3.shape[0] * 2)
self.data3[:tmp.shape[0]] = tmp
self.data4[:tmp2.shape[0]] = tmp2
self.data3_x = np.linspace(0, self.data3.shape[0] - 1,
self.data3.shape[0]) * 0.002
self.data4_x = np.linspace(0, self.data3.shape[0] - 1,
self.data3.shape[0]) * 0.002
self.line3.setData(x=self.data3_x[:self.ptrFilter],
y=self.data3[:self.ptrFilter])
self.line3.setPos(-self.ptrFilter * 0.002, 0)
self.line4.setData(x=self.data4_x[:self.ptrFilter],
y=self.data4[:self.ptrFilter])
self.line4.setPos(-self.ptrFilter * 0.002, 0)
self.timerCount += 0.04
if self.timerCount > self.measure_time:
self.pausedMeasure()
self.paused.setDisabled(True)
self.lLabel.setText("측정이 끝났습니다. 수고하셨습니다.")
