a layout

.gitignore

@@ -248,3 +248,6 @@ pyproject.toml*~
 .cache
 /doc/_build/*
 *pycache*
+
+# testers
+tst_*

omc3_gui/plotting/classes.py

@@ -0,0 +1,66 @@
+
+
+import pyqtgraph as pg
+from accwidgets.graph import StaticPlotWidget
+from accwidgets.graph.widgets.plotitem import ExViewBox
+
+class DualPlot(pg.LayoutWidget):
+
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+
+ self.top = PlotWidget()
+ self.bottom = PlotWidget()
+
+ self.addWidget(self.top, row=0, col=0)
+ self.addWidget(self.bottom, row=1, col=0)
+
+ # self.top.setMouseMode(pg.ViewBox.RectMode)
+ # self.bottom.setMouseMode(pg.ViewBox.PanMode)
+
+ @property
+ def plots(self):
+ return (self.top, self.bottom)
+
+
+ def connect_x(self) -> None:
+ pass
+
+ def connect_y(self) -> None:
+ pass
+
+
+class PlotWidget(StaticPlotWidget):
+
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs, viewBox=ZoomingViewBox())
+
+ # fixes for our plots
+ self.setBackground("w")
+ self.plotItem.getViewBox().setMouseMode(ZoomingViewBox.RectMode)
+
+
+class ZoomingViewBox(ExViewBox):
+ pass
+
+ # def mouseDragEvent(self, ev):
+
+ # if ev.button() == QtCore.Qt.RightButton:
+ # ev.ignore()
+ # else:
+ # pg.ViewBox.mouseDragEvent(self, ev)
+
+ # ev.accept()
+ # pos = ev.pos()
+ # if ev.button() == QtCore.Qt.RightButton:
+ # if ev.isFinish():
+ # self.rbScaleBox.hide()
+ # self.ax = QtCore.QRectF(
+ # pg.Point(ev.buttonDownPos(ev.button())), pg.Point(pos)
+ # )
+ # self.ax = self.childGroup.mapRectFromParent(self.ax)
+ # self.Coords = self.ax.getCoords()
+ # self.getdataInRect()
+ # self.changePointsColors()
+ # else:
+ # self.updateScaleBox(ev.buttonDownPos(), ev.pos())

omc3_gui/sbs_matcher.py

@@ -0,0 +1,42 @@
+import logging
+import sys
+from pathlib import Path
+
+from qtpy import QtWidgets
+
+from omc3_gui.segment_by_segment_matcher.constants import LHC_YEARS 
+from omc3_gui.segment_by_segment_matcher.main import SbSGuiMainController
+from omc3_gui.utils import log_handler
+
+LOGGER = logging.getLogger(__name__)
+
+
+def main(lhc_year=None, match_path=None, input_dir=None):
+ app = QtWidgets.QApplication(sys.argv)
+ app.setStyle("fusion")
+ main_controller = SbSGuiMainController()
+ if match_path is None or lhc_year is None:
+ lhc_year, match_path = main_controller.ask_for_initial_config(
+ lhc_year,
+ match_path,
+ )
+ if match_path is None or lhc_year is None:
+ return
+ match_path = Path(match_path)
+ log_handler.add_file_handler(match_path)
+ if lhc_year not in LHC_YEARS:
+ raise ValueError(f"Invalid lhc mode, must be one of {LHC_YEARS!s}")
+ LOGGER.info("-------------------- ")
+ LOGGER.info("Configuration:")
+ LOGGER.info(f"- LHC year: {lhc_year!s}")
+ LOGGER.info(f"- Match output path: {match_path!s}")
+ LOGGER.info("-------------------- ")
+ main_controller.set_match_path(match_path)
+ main_controller.set_lhc_mode(lhc_year)
+ main_controller.set_input_dir(input_dir)
+ main_controller.show_view()
+ sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+ main(lhc_year="2018", match_path=Path("/mnt/volume/jdilly/temp/"))

omc3_gui/segment_by_segment.py

@@ -1,42 +1,7 @@
+from omc3_gui.segment_by_segment.controller import SbSController
+from omc3_gui.utils.log_handler import init_logging
 import logging
-import sys
-from pathlib import Path
-
-from qtpy import QtWidgets
-
-from omc3_gui.segment_by_segment_matcher.constants import LHC_YEARS 
-from omc3_gui.segment_by_segment_matcher.main import SbSGuiMainController
-from omc3_gui.utils import log_handler
-
-LOGGER = logging.getLogger(__name__)
-
-
-def main(lhc_year=None, match_path=None, input_dir=None):
- app = QtWidgets.QApplication(sys.argv)
- app.setStyle("fusion")
- main_controller = SbSGuiMainController()
- if match_path is None or lhc_year is None:
- lhc_year, match_path = main_controller.ask_for_initial_config(
- lhc_year,
- match_path,
- )
- if match_path is None or lhc_year is None:
- return
- match_path = Path(match_path)
- log_handler.add_file_handler(match_path)
- if lhc_year not in LHC_YEARS:
- raise ValueError(f"Invalid lhc mode, must be one of {LHC_YEARS!s}")
- LOGGER.info("-------------------- ")
- LOGGER.info("Configuration:")
- LOGGER.info(f"- LHC year: {lhc_year!s}")
- LOGGER.info(f"- Match output path: {match_path!s}")
- LOGGER.info("-------------------- ")
- main_controller.set_match_path(match_path)
- main_controller.set_lhc_mode(lhc_year)
- main_controller.set_input_dir(input_dir)
- main_controller.show_view()
- sys.exit(app.exec_())
-
 
 if __name__ == "__main__":
- main(lhc_year="2018", match_path=Path("/mnt/volume/jdilly/temp/"))
+ init_logging(level=logging.DEBUG)
+ SbSController.run_application()

omc3_gui/segment_by_segment/controller.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+from omc3_gui.utils.base_classes import Controller
+from omc3_gui.utils.dialogs import OpenDirectoriesDialog, OpenDirectoryDialog
+from omc3_gui.segment_by_segment.view import SbSWindow
+from omc3_gui.segment_by_segment.model import Measurement, Settings
+from qtpy.QtCore import Qt, Signal, Slot
+from qtpy.QtWidgets import QFileDialog
+import logging
+
+LOG = logging.getLogger(__name__)
+
+class SbSController(Controller):
+
+ settings: Settings
+ _view: SbSWindow # for the IDE
+
+ def __init__(self):
+ super().__init__(SbSWindow())
+ self.connect_signals()
+ self.settings = Settings()
+ self._last_selected_optics_path = None
+
+
+ def add_measurement(self, measurement: Measurement):
+ self._view.get_measurement_list().add_item(measurement) 
+
+
+ def connect_signals(self):
+ self._view.sig_load_button_clicked.connect(self.open_measurements)
+
+
+ @Slot()
+ def open_measurements(self):
+ LOG.debug("OpenButton Clicked. Asking for folder paths.")
+ filenames = OpenDirectoriesDialog(
+ parent=self._view,
+ caption="Select Optics Folders", 
+ directory=str(self._last_selected_optics_path) if self._last_selected_optics_path else None,
+ ).run_selection_dialog()
+
+ loaded_measurements = self._view.get_measurement_list()
+
+ LOG.debug(f"User selected {len(filenames)} files.")
+ for filename in filenames:
+ self._last_selected_optics_path = filename.parent
+ LOG.debug(f"User selected: {filename}")
+ loaded_measurements.add_item(Measurement(filename))
+
+
+

omc3_gui/segment_by_segment/model.py

@@ -0,0 +1,143 @@
+from dataclasses import dataclass
+from pathlib import Path
+import types
+from typing import Any, Dict, List, Sequence, Union
+from accwidgets.graph import StaticPlotWidget
+import pyqtgraph as pg
+from omc3.segment_by_segment.segments import Segment
+
+from typing import List
+from qtpy import QtCore
+from qtpy.QtCore import Qt
+
+
+@dataclass
+class Measurement:
+ measurement_dir: Path
+ output_dir: Path = None
+ elements: Dict[str, Segment] = None
+ segments: Dict[str, Segment] = None
+ model_dir: Path = None
+ accel: str = None
+ year: str = None
+ ring: int = None
+
+ def __str__(self):
+ return str(self.measurement_dir)
+
+
+
+@dataclass
+class Settings:
+ pass
+
+
+
+class ItemDictModel:
+
+ def __init__(self):
+ self.items = {}
+
+ def try_emit(self, emit: bool = True):
+ if not emit:
+ return
+
+ if hasattr(self, "layoutChanged"):
+ self.layoutChanged.emit()
+
+ def update_item(self, item):
+ self.items[str(item)] = item
+ self.try_emit()
+
+ def add_item(self, item, emit: bool = True):
+ name = str(item)
+ if name in self.items.keys():
+ raise ValueError(f"Item {name} already exists")
+ self.items[name] = item
+ self.try_emit(emit)
+
+ def add_items(self, items: Sequence):
+ for item in items:
+ self.add_item(item, emit=False)
+ self.try_emit()
+
+ def remove_item(self, item, emit: bool = True):
+ self.items.pop(str(item))
+ self.try_emit(emit)
+
+ def remove_items(self, items: Sequence):
+ for item in items:
+ self.remove_item(item, emit=False)
+ self.try_emit()
+
+ def remove_all_items(self):
+ self.items = {}
+ self.try_emit()
+
+ def remove_item_at(self, index: int):
+ self.remove_item(self.get_item_at(index))
+
+ def remove_items_at(self, indices: Sequence):
+ self.remove_items([self.get_item_at(index) for index in indices])
+
+ def get_item_at(self, index: int) -> Any:
+ return list(self.items.values())[index]
+
+
+
+class MeasurementListModel(QtCore.QAbstractListModel, ItemDictModel):
+
+ items: Dict[str, Measurement] # for the IDE
+
+ def __init__(self, *args, **kwargs):
+ super(QtCore.QAbstractListModel, self).__init__(*args, **kwargs)
+ super(ItemDictModel, self).__init__()
+
+ def data(self, index: QtCore.QModelIndex, role: int = Qt.DisplayRole):
+ meas: Measurement = self.get_item_at(index.row())
+ if role == Qt.DisplayRole: # https://doc.qt.io/qt-5/qt.html#ItemDataRole-enum
+ return str(meas)
+
+ if role == Qt.EditRole:
+ return meas
+
+ def rowCount(self, index):
+ return len(self.items)
+
+
+class SegmentTableModel(QtCore.QAbstractTableModel, ItemDictModel):
+
+ _COLUMNS = {0: "Segment", 1: "Start", 2: "End"}
+ _COLUMNS_MAP = {0: "name", 1: "start", 2: "end"}
+
+ items: Dict[str, Segment]
+
+ def __init__(self, *args, **kwargs): 
+ super().__init__(*args, **kwargs)
+ super(QtCore.QAbstractTableModel, self).__init__(*args, **kwargs)
+ super(ItemDictModel, self).__init__()
+
+ def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
+ if orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole:
+ return self._COLUMNS[section]
+ return super().headerData(section, orientation, role)
+
+ def rowCount(self, parent=QtCore.QModelIndex()):
+ return len(self.items) 
+
+ def columnCount(self, parent=QtCore.QModelIndex()):
+ return len(self._COLUMNS) 
+
+ def data(self, index, role=QtCore.Qt.DisplayRole):
+ i = index.row()
+ j = index.column()
+ segment: Segment = self.get_item_at(i)
+
+ if role == QtCore.Qt.DisplayRole:
+ return str(getattr(segment, self._COLUMNS_MAP[j]))
+
+ if role == Qt.EditRole:
+ return segment 
+
+ def flags(self, index):
+ return QtCore.Qt.ItemIsEnabled