params/system_params.json

@@ -1,19 +1,19 @@
 {
-    "a_max_1": 5.41,
-    "v_max_1": 0.108,
-    "a_max_2": 35.81,
-    "v_max_2": 0.678,
-    "mass_1": 257,
-    "mass_2": 1,
-    "k_hardness_1": 1759291,
-    "k_hardness_2": 0,
-    "torque_max_1": 20,
-    "torque_max_2": 0,
-    "transmission_ratio_1": 0.00125,
-    "transmission_ratio_2": 1,
-    "position_start_1": 0.08,
-    "position_start_2": 0.08,
-    "k_prop": 0.05,
-    "time_capture": 100000,
+    "a_max_1" : 5.41,
+    "v_max_1" : 0.108,
+    "a_max_2" : 35.81,
+    "v_max_2" : 0.678,
+    "mass_1" : 257,
+    "mass_2" : 1,
+    "k_hardness_1" : 1759291,
+    "k_hardness_2" : 0,
+    "torque_max_1" : 20,
+    "torque_max_2" : 0,
+    "transmission_ratio_1" : 0.00125,
+    "transmission_ratio_2" : 1,
+    "position_start_1" : 0.080,
+    "position_start_2" : 0.080,
+    "k_prop" : 0.05,
+    "time_capture" : 100000,
     "UML_time_scaler": 1000
 }

requirements.txt

@@ -11,7 +11,7 @@ pillow==11.0.0
 plantuml==0.3.0
 pyparsing==3.2.0
 PyQt5==5.15.11
-PyQt5-Qt5==5.15.2
+PyQt5-Qt5==5.15.15
 PyQt5_sip==12.15.0
 pyqtgraph==0.13.7
 python-dateutil==2.9.0.post0

src/__init__.py

@@ -1 +0,0 @@
-

src/gui/__init__.py

@@ -1,3 +1 @@
 from .plot_window import PlotWindow
-from .settings_window import settingsWindow
-from .app  import app

src/gui/app.py

@@ -1,77 +0,0 @@
-import pyqtgraph as pg
-
-from src.utils import read_json, DiagramParser
-from src.uml import Request, UMLCreator
-from src.OptAlgorithm import OptAlgorithm
-from src.gui import PlotWindow, settingsWindow
-
-
-class app:
-    def __init__(self):
-
-        self.parser = DiagramParser()
-        self.request_generator = Request(server_url='http://www.plantuml.com/plantuml/svg/')
-
-        self.operSettings = settingsWindow("params\operator_params.json", 'Operator', self._update_settings)
-        self.sysSettings = settingsWindow("params\system_params.json", 'System', self._update_settings)
-        
-        self._load_preset()
-        
-
-    def _get_ideal_timings(self, opt: OptAlgorithm) -> list[float]:
-        data = opt.Ts
-        ideal_time = [data['tclose'], data['tgrow'], opt.getMarkOpen()]
-        return ideal_time
-
-    def _load_preset(self):
-        self.operator_params = read_json("params/operator_params.json")
-        self.system_params = read_json("params/system_params.json")
-
-        self.opt_algorithm = OptAlgorithm(operator_config=self.operator_params, system_config=self.system_params)
-        self.ideal_times = self._get_ideal_timings(self.opt_algorithm)
-
-        self.parser.setData("trace_samples/2024_11_01-09_39_17B00.csv")
-        self.bool_dict = self.parser.getBoolDict()
-        self.float_dict = self.parser.getFloatDict()
-
-        self.plotter = PlotWindow(operator_config=self.operator_params,
-                        system_config=self.system_params,
-                        opt=self.opt_algorithm,
-                        bool_dict=self.bool_dict,
-                        float_dict=self.float_dict, 
-                        show_settings_func=self._show_settings)
-        
-        self.uml_creator = UMLCreator(system_config=self.system_params,
-                                request_generator=self.request_generator,
-                                ideal_time=self.ideal_times,
-                                bool_dict=self.bool_dict,
-                                float_dict=self.float_dict)
-
-    def _update_settings(self, _):
-        self.operator_params = self.operSettings.getParams()
-        self.system_params = self.sysSettings.getParams()
-
-        self.opt_algorithm = OptAlgorithm(operator_config=self.operator_params, system_config=self.system_params)
-        self.ideal_times = self._get_ideal_timings(self.opt_algorithm)
-
-        self.uml_creator.update_uml(system_config=self.system_params,
-                                request_generator=self.request_generator,
-                                ideal_time=self.ideal_times,
-                                bool_dict=self.bool_dict,
-                                float_dict=self.float_dict)
-        
-        self.plotter.update_data(operator_config=self.operator_params,
-                        system_config=self.system_params,
-                        opt=self.opt_algorithm,
-                        bool_dict=self.bool_dict,
-                        float_dict=self.float_dict)
-        
-    def _show_settings(self):
-        self.operSettings.show()
-        self.sysSettings.show()
-
-
-if __name__ == '__main__':
-    pg.mkQApp("Plotting")
-    temp = app()
-    pg.exec()

src/gui/plot_window.py

@@ -1,9 +1,7 @@
 import pyqtgraph as pg
-from pyqtgraph.Qt import QtWidgets
 import numpy as np
 
 from src.gui import qt_settings as qts
-
 from src.OptAlgorithm import OptAlgorithm
 
 
@@ -13,48 +11,25 @@ class PlotWindow:
                  operator_config: dict,
                  opt: OptAlgorithm,
                  bool_dict: dict,
-                 float_dict: dict, show_settings_func):
+                 float_dict: dict):
         pg.setConfigOptions(antialias=True)
         self.opt = opt
         self.bool_dict = bool_dict
         self.float_dict = float_dict
         self.scaler = int(system_config['UML_time_scaler'])
         self.WeldTime = operator_config['time_wielding'] #[sec]
+
+        
+        self._getIdealTimings()
+        self._init_app()
         self.alpha = 100 #[0-255 прозрачность фона]
 
-        self._getIdealTimings()
-        self._init_ui()
-        self.settings_button.clicked.connect(show_settings_func)
-        
-
-    def update_data(self, 
-                    system_config : dict,
-                    operator_config: dict,
-                    opt: OptAlgorithm,
-                    bool_dict: dict,
-                    float_dict: dict):
-        self.opt = opt
-        self.bool_dict = bool_dict
-        self.float_dict = float_dict
-        self.scaler = int(system_config['UML_time_scaler'])
-        self.WeldTime = operator_config['time_wielding'] #[sec]
-        self._getIdealTimings()
-        self._updatePlots()
-    
-    def _init_ui(self):
-        self.widget = QtWidgets.QWidget()
-        layout = QtWidgets.QVBoxLayout()
-        self.widget.setLayout(layout)
-
+    def _init_app(self):
+        self.app = pg.mkQApp("Plotting")
         self.win = pg.GraphicsLayoutWidget(show=True, title="")
         self.win.resize(1000,600)
         self.win.setWindowTitle('')
 
-        layout.addWidget(self.win)
-        self.settings_button = QtWidgets.QPushButton("Show settings")
-        self.settings_button.setFixedWidth(160)
-        layout.addWidget(self.settings_button)
-
         self.p11, self.l11 = self._init_graph('Electrode force, closure', 'Force', 'N', 'Time', 'ms')
         #self.p21, _ = self._init_graph('Electrode force, compression', 'Force', 'N', 'Time', 'ms')
         #self.p31, _ = self._init_graph('Electrode force, compression', 'Force', 'N', 'Time', 'ms')
@@ -74,27 +49,17 @@ class PlotWindow:
         self.p11.setAutoVisible(x=False, y=True)
         self.p12.setAutoVisible(x=False, y=True)
         self.p13.setAutoVisible(x=False, y=True)
-        self._updatePlots()
-        self.widget.setStyleSheet(qts.dark_style)
-        self.widget.show()
 
     def _init_graph(self, title, Yname, Yunits, Xname, Xunits):
-        plot = self.win.addPlot(title = title)
-        plot.showGrid(x=True, y=True)
-        plot.setLabel('left', Yname, units=Yunits)
-        plot.setLabel('bottom', Xname, units=Xunits)
+        p11 = self.win.addPlot(title = title)
+        p11.showGrid(x=True, y=True)
+        p11.setLabel('left', Yname, units=Yunits)
+        p11.setLabel('bottom', Xname, units=Xunits)
         legend1 = pg.LegendItem((80,60), offset=(70,20))
-        legend1.setParentItem(plot)
-        return plot, legend1
-
-    def _updatePlots(self):
-        self.p11.clear()
-        self.l11.clear()
-        self.p12.clear()
-        self.l12.clear()
-        self.p13.clear()
-        self.l13.clear()
+        legend1.setParentItem(p11)
+        return p11, legend1
 
+    def updatePlots(self):
         self._plotRealData()
         times = np.arange(20000)/10
         self._plotIdealData(times)
@@ -204,8 +169,8 @@ class PlotWindow:
 
     def _makeFiller(self, x1, y1, x2, y2, color):
         alpha = self.alpha
-        eq1 = pg.PlotDataItem(x1, y1, pen=pg.mkPen(color='#000000', width=1))
-        eq2 = pg.PlotDataItem(x2, y2, pen=pg.mkPen(color='#000000', width=1))
+        eq1 = pg.PlotDataItem(x1, y1, pen=pg.mkPen(color='#000000', width=2))
+        eq2 = pg.PlotDataItem(x2, y2, pen=pg.mkPen(color='#000000', width=2))
         bg = pg.FillBetweenItem(eq1, eq2, qts.RGBA[color]+(alpha,))
         return eq1, eq2, bg
 

src/gui/qt_settings.py

@@ -57,7 +57,7 @@ QRadioButton {
 """
 
 dark_style = """
-QWidget {
+QMainWindow {
     background-color: #0D1117;  /* Тёмный, современный цвет для фона */
     font-family: "Segoe UI", sans-serif;
     font-size: 14px;

src/gui/settings_window.py

@@ -1,59 +0,0 @@
-import pyqtgraph as pg
-from pyqtgraph.Qt import QtWidgets
-from pyqtgraph.parametertree import Parameter, ParameterTree
-
-from src.utils.json_tools import read_json, write_json
-from src.gui import qt_settings as qts
-
-class settingsWindow(QtWidgets.QWidget):
-    def __init__(self, path: str, name: str, upd_func):
-        super(settingsWindow, self).__init__()
-        self.settingsPath = path
-        self.name = name
-        
-        self.data = {}
-        self.params = None
-        self.load_settings()
-        self._init_ui()
-        self.params.sigTreeStateChanged.connect(upd_func)
-
-    def load_settings(self):
-        self.data = read_json(self.settingsPath)
-
-    def write_settings(self):
-        self.getParams()
-        write_json(self.settingsPath, self.data)
-
-    def _getTreeStructure(self) -> list:
-        params = []
-        for key, value in self.data.items():
-            params.append({'name': str(key), 'type': type(value).__name__, 'value': value})
-        params.append({'name': 'Save', 'type': 'action'})
-        return params
-    
-    def _init_ui(self):
-        temp = self._getTreeStructure()
-        self.params = Parameter.create(name=self.name, type='group', children=temp)
-        self.params.param('Save').sigActivated.connect(self.write_settings)
-
-        ParamsTree = ParameterTree()
-        ParamsTree.setParameters(self.params, showTop=True)
-        layout = QtWidgets.QGridLayout()
-        layout.addWidget(ParamsTree, 0,0)
-        self.setLayout(layout)
-        self.setStyleSheet(qts.white_style)
-       # self.show()
-        
-    def getParams(self) -> dict:
-        self.data = {}
-        for p in self.params:
-            if p.name() != 'Save':
-                self.data[p.name()] = p.value()
-        return self.data
-
-if __name__ == '__main__':
-    app = pg.mkQApp("Parameter Tree Example")
-    window = settingsWindow('params\operator_params.json', 'operator')
-    app.exec()
-
-    

src/main.py

@@ -1,10 +1,43 @@
 import pyqtgraph as pg
 
-from src.gui import app
+from src.utils import read_json, DiagramParser
+from src.uml import Request, UMLCreator
+from src.OptAlgorithm import OptAlgorithm
+from src.gui import PlotWindow
+
+
+def get_ideal_timings(opt: OptAlgorithm) -> list[float]:
+    data = opt.Ts
+    ideal_time = [data['tclose'], data['tgrow'], opt.getMarkOpen()]
+    return ideal_time
+
 
 def main():
-    pg.mkQApp("Plotting")
-    temp = app()
+    operator_params = read_json("params/operator_params.json")
+    system_params = read_json("params/system_params.json")
+    opt_algorithm = OptAlgorithm(operator_config=operator_params, system_config=system_params)
+    ideal_times = get_ideal_timings(opt_algorithm)
+
+    parser = DiagramParser()
+    parser.setData("trace_samples/2024_11_01-09_39_17B00.csv")
+    bool_dict = parser.getBoolDict()
+    float_dict = parser.getFloatDict()
+
+    request_generator = Request(server_url='http://www.plantuml.com/plantuml/svg/')
+    uml_creator = UMLCreator(system_config=system_params,
+                             request_generator=request_generator,
+                             ideal_time=ideal_times,
+                             bool_dict=bool_dict,
+                             float_dict=float_dict)
+    uml_creator.update_uml()
+
+    app = PlotWindow(operator_config=operator_params,
+                     system_config=system_params,
+                     opt=opt_algorithm,
+                     bool_dict=bool_dict,
+                     float_dict=float_dict)
+
+    app.updatePlots()
     pg.exec()
 
 

src/uml/creator.py

@@ -95,18 +95,6 @@ class UMLCreator:
         except Exception as e:
             print(f"SVG generate error: {e}")
 
-    def update_uml(self, 
-                 system_config : dict,
-                 request_generator: Request,
-                 ideal_time: list[float],
-                 bool_dict: dict,
-                 float_dict: dict):
-        
-        self._request_generator = request_generator
-        self._ideal_time = ideal_time
-        self.bool_dict = bool_dict
-        self.float_dict = float_dict
-        self.scaler = int(system_config['UML_time_scaler'])
-        
+    def update_uml(self) -> None:
         real, client, ideal, bool_ = self._build_data()
         self._generate_svg(real, client, ideal, bool_)

src/utils/__init__.py

@@ -1,2 +1,2 @@
-from .json_tools import read_json, write_json
+from .json_tools import read_json
 from .diagram_parser import DiagramParser

src/utils/json_tools.py

@@ -9,13 +9,3 @@ def read_json(filepath: str) -> dict:
     with open(filepath, 'r') as json_file:
         data = json.load(json_file)
         return data
-
-def write_json(filepath: str, data: dict):
-    if not path.exists(filepath):
-        raise FileNotFoundError(f"JSON file {filepath} not found!")
-
-    try:
-        with open(filepath, 'w') as json_file:
-            json.dump(data, json_file, indent=4)
-    except Exception as e:
-        raise e