dev: добавлены эквидистанты

params/operator_params.json

@@ -7,7 +7,7 @@
     "dist_open_end_2" : 0.050,
     "dist_close_end_1" : 0.005,
     "dist_close_end_2" : 0.005,
-    "time_wielding" : 2,
+    "time_wielding" : 1,
     "time_command" : 0.060,
     "time_robot_movement" : 0.2,
     "object_thickness" : 4.5e-3,

params/system_params.json

@@ -14,5 +14,6 @@
     "position_start_1" : 0.080,
     "position_start_2" : 0.080,
     "k_prop" : 0.05,
-    "time_capture" : 100000
+    "time_capture" : 100000,
+    "UML_time_scaler": 1000
 }

src/gui/plot_window.py

@@ -7,6 +7,8 @@ from src.OptAlgorithm import OptAlgorithm
 
 class PlotWindow:
     def __init__(self,
+                 system_config : dict,
+                 operator_config: dict,
                  opt: OptAlgorithm,
                  bool_dict: dict,
                  float_dict: dict):
@@ -14,11 +16,12 @@ class PlotWindow:
         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.scaler = 1000
         self._getIdealTimings()
         self._init_app()
-        self.WeldTime = 1.0 #[sec]  # TODO: to external config
         self.alpha = 100 #[0-255 прозрачность фона]
 
     def _init_app(self):
@@ -70,6 +73,12 @@ class PlotWindow:
         self.idealPhase1 = (self.idealTime[0]+ self.idealTime[1])*self.scaler                                    #Сжатие
         self.idealPhase2 = (self.idealTime[0]+ self.idealTime[1] + self.WeldTime)*self.scaler                     #Сварка
         self.idealPhase3 = (self.idealTime[0]+ self.idealTime[1] + self.idealTime[2] + self.WeldTime)*self.scaler #Разъезд
+        self.idealPhase4 = (self.idealTime[0]+ self.idealTime[1] + self.idealTime[2] + self.WeldTime + 0.25)*self.scaler #Последнее смыкание  #TODO добавить идеальное время вместо 0.25
+        self.x_splitter = np.array([[0, self.idealPhase0],
+             [self.idealPhase0, self.idealPhase1],
+             [self.idealPhase1, self.idealPhase2],
+             [self.idealPhase2, self.idealPhase3],
+             [self.idealPhase3, self.idealPhase4]])
         data = []
         for time in times:
             if time <= self.idealPhase0:
@@ -124,16 +133,13 @@ class PlotWindow:
         self.p13.addItem(v_me)
         self.l13.addItem(v_me, 'ME VEL')
         self._addBackgroundSplitter()
+        self._addEquidistances(times, data)
 
     def _addBackgroundSplitter(self):
         alpha = self.alpha
-        x = [[0, self.idealPhase0],
+        y01 = np.array([10000, 10000])
-             [self.idealPhase0, self.idealPhase1],
+        y0_1 = np.array([-10000, -10000])
-             [self.idealPhase1, self.idealPhase2],
+        for i, _ in enumerate(self.x_splitter):
-             [self.idealPhase2, self.idealPhase3]]
-        y01 = [10000, 10000]
-        y0_1 = [-10000, -10000]
-        for i, _ in enumerate(x):
             a01 = pg.PlotDataItem(_, y01, pen=pg.mkPen(color=qts.colors[8], width=2), name=' ')
             a0_1 = pg.PlotDataItem(_, y0_1, pen=pg.mkPen(color=qts.colors[8], width=2), name=' ')
             bg1 = pg.FillBetweenItem(a01, a0_1, qts.RGBA[i]+(alpha,))
@@ -146,3 +152,56 @@ class PlotWindow:
         self.p11.setYRange(-1000, 5000)
         self.p12.setYRange(-50, 250)
         self.p13.setYRange(-400, 400)
+
+    def _addEquidistances(self, times, data):
+        a1, b1, c1 = self._calculate_equidistant('fill', max(data[4]), 2.5, self.x_splitter[1], 3)
+        self.p11.addItem(a1)
+        self.p11.addItem(b1)
+        self.p11.addItem(c1)
+
+        a1, b1, c1 = self._calculate_equidistant(times, data[4], 0.75, self.x_splitter[2], 3)
+        self.p11.addItem(a1)
+        self.p11.addItem(b1)
+        self.p11.addItem(c1)
+
+        
+
+
+    def _makeFiller(self, x1, y1, x2, y2, color):
+        alpha = self.alpha
+        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
+
+
+    def _calculate_equidistant(self, x, y, percent, splitter, color):
+        if str(x) == 'fill':
+            x = [splitter[0]+0.001, splitter[0]+0.002, splitter[1]-0.002, splitter[1]-0.001]
+            y = [y, y, y, y]
+        
+        if len(x) != len(y):
+            raise ValueError("x и y должны быть одного размера")
+        distance = max(y)/100*percent
+        x_eq1 = []
+        y_eq1 = []
+        x_eq2 = []
+        y_eq2 = []
+
+        for i in range(0, len(x) - 1):
+            if splitter[0]<=  x[i] and x[i] <= splitter[1]:
+                
+                dx = x[i + 1] - x[i]
+                dy = y[i + 1] - y[i]
+                length = np.sqrt(dx ** 2 + dy ** 2)
+                sinA = dy/length
+                sinB = dx/length
+                
+                nx = -sinA*distance
+                ny = sinB*distance
+                x_eq1.append(x[i] + nx)
+                y_eq1.append(y[i] + ny)
+                x_eq2.append(x[i] - nx)
+                y_eq2.append(y[i] - ny)
+        
+        return self._makeFiller(np.array(x_eq1), np.array(y_eq1), np.array(x_eq2), np.array(y_eq2), color)

src/gui/qt_settings.py

@@ -251,5 +251,6 @@ colors = [
 RGBA = [(255, 255, 0),
         (32, 178, 70),
         (255, 69, 0),
-        (123, 104, 238)
+        (123, 104, 238),
+        (99, 42, 15)
 ]

src/main.py

@@ -1,9 +1,9 @@
 import pyqtgraph as pg
 
-from utils import read_json, DiagramParser
+from src.utils import read_json, DiagramParser
-from uml import Request, UMLCreator
+from src.uml import Request, UMLCreator
-from OptAlgorithm import OptAlgorithm
+from src.OptAlgorithm import OptAlgorithm
-from gui import PlotWindow
+from src.gui import PlotWindow
 
 
 def get_ideal_timings(opt: OptAlgorithm) -> list[float]:
@@ -24,13 +24,16 @@ def main():
     float_dict = parser.getFloatDict()
 
     request_generator = Request(server_url='http://www.plantuml.com/plantuml/svg/')
-    uml_creator = UMLCreator(request_generator=request_generator,
+    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(opt=opt_algorithm,
+    app = PlotWindow(operator_config=operator_params,
+                     system_config=system_params,
+                     opt=opt_algorithm,
                      bool_dict=bool_dict,
                      float_dict=float_dict)
 

src/uml/creator.py

@@ -3,6 +3,7 @@ from src.uml.request_generator import Request
 
 class UMLCreator:
     def __init__(self, 
+                 system_config : dict,
                  request_generator: Request,
                  ideal_time: list[float],
                  bool_dict: dict,
@@ -11,9 +12,10 @@ class UMLCreator:
         self._ideal_time = ideal_time
         self.bool_dict = bool_dict
         self.float_dict = float_dict
+        self.scaler = int(system_config['UML_time_scaler'])
+
 
     def _build_data(self):
-        scaler = 1000  # TODO: external config?
         sig = [
             'Electrode Closing Algorithm Execute',  # Начало закрытия
             'Electrode Closing Algorithm Done',
@@ -39,25 +41,25 @@ class UMLCreator:
         ]
 
         client_data = [
-            [0.0 * scaler, 'closure'],
+            [0.0 * self.scaler, 'closure'],
-            [0.165 * scaler, '{-}'],
+            [0.165 * self.scaler, '{-}'],
-            [0.166 * scaler, 'compression'],
+            [0.166 * self.scaler, 'compression'],
-            [0.176 * scaler, '{-}'],
+            [0.176 * self.scaler, '{-}'],
-            # [0.180*scaler, 'welding'],
+            # [0.180*self.scaler, 'welding'],
-            # [0.200*scaler, '{-}'],
+            # [0.200*self.scaler, '{-}'],
-            [0.210 * scaler, 'opening'],
+            [0.210 * self.scaler, 'opening'],
-            [0.300 * scaler, '{-}'],
+            [0.300 * self.scaler, '{-}'],
         ]
 
         ideal_data = [
-            [0.0 * scaler, 'closure #yellow'],
+            [0.0 * self.scaler, 'closure #yellow'],
-            [self._ideal_time[0] * scaler, '{-}'],
+            [self._ideal_time[0] * self.scaler, '{-}'],
-            [(self._ideal_time[0] + 0.0001) * scaler, 'compression #yellow'],
+            [(self._ideal_time[0] + 0.0001) * self.scaler, 'compression #yellow'],
-            [(self._ideal_time[0] + self._ideal_time[1]) * scaler, '{-}'],
+            [(self._ideal_time[0] + self._ideal_time[1]) * self.scaler, '{-}'],
-            # [0.*scaler, 'welding #yellow'],
+            # [0.*self.scaler, 'welding #yellow'],
-            # [0.*scaler, '{-}'],
+            # [0.*self.scaler, '{-}'],
-            [(self._ideal_time[0] + self._ideal_time[1] + 0.0001) * scaler, 'opening #yellow'],
+            [(self._ideal_time[0] + self._ideal_time[1] + 0.0001) * self.scaler, 'opening #yellow'],
-            [(self._ideal_time[0] + self._ideal_time[1] + self._ideal_time[2]) * scaler, '{-}'],
+            [(self._ideal_time[0] + self._ideal_time[1] + self._ideal_time[2]) * self.scaler, '{-}'],
         ]
         return real_data, client_data, ideal_data, self.bool_dict