fix: исправлена генегация V этапа в UML + добавлен допуск для II и II этапов в графиках

src/gui/app.py

@@ -13,7 +13,7 @@ class app:
 
     def _get_ideal_timings(self, opt: OptAlgorithm) -> list[float]:
         data = opt.Ts
-        ideal_time = [data['tclose'], data['tgrow'], opt.getMarkOpen()]
+        ideal_time = [data['tclose'], data['tgrow'], opt.getMarkOpen(), data["tmovement"]]
         return ideal_time
 
     def _load_preset(self):
@@ -21,7 +21,7 @@ class app:
         self.system_params = read_json("params/system_params.json")
 
         self.parser = DiagramParser(system_config=self.system_params)
-        self.parser.setData("")
+        self.parser.setData("trace_samples/2024_11_08-19_30_52.csv")
         #trace_samples/2024_11_08-19_30_52.csv
         
 
@@ -51,6 +51,7 @@ class app:
         self.plotter.update_data(operator_config=self.operator_params,
                         system_config=self.system_params,
                         opt=self.opt_algorithm,
+                        ideal_time=self.ideal_times,
                         bool_dict=self.bool_dict,
                         float_dict=self.float_dict,
                         mode = self.mode,
@@ -75,6 +76,7 @@ class app:
                         system_config=self.system_params,
                         opt=self.opt_algorithm,
                         bool_dict=self.bool_dict,
+                        ideal_time=self.ideal_times,
                         float_dict=self.float_dict,
                         mode = self.mode,
                         timings_dict=self.timings_dict)

src/gui/plot_window.py

@@ -12,7 +12,6 @@ class PlotWindow:
         pg.setConfigOptions(antialias=True)
         self.alpha = 100 #[0-255 прозрачность фона]
         self.opt = opt
-        self._getIdealTimings()
         self._init_ui()
         self.settings_button.clicked.connect(show_settings_func)
         
@@ -21,6 +20,7 @@ class PlotWindow:
                     system_config : dict,
                     operator_config: dict,
                     opt: OptAlgorithm,
+                    ideal_time: list[float],
                     bool_dict: dict,
                     float_dict: dict,
                     timings_dict: dict,
@@ -29,10 +29,11 @@ class PlotWindow:
         self.bool_dict = bool_dict
         self.float_dict = float_dict
         self.timings_dict = timings_dict
+        self.idealTime = ideal_time
         self.theor_mode = mode
         self.scaler = int(system_config['UML_time_scaler'])
         self.WeldTime = operator_config['time_wielding'] #[sec]
-        self._getIdealTimings()
+        self.WeldData = self.opt.calcPhaseGrow(self.idealTime[1])
         self._updatePlots()
     
     def _init_ui(self):
@@ -92,10 +93,6 @@ class PlotWindow:
             self._plotRealData()
         self._form_idealdatGraph()
 
-    def _getIdealTimings(self):
-        data = self.opt.Ts
-        self.idealTime = [data['tclose'], data['tgrow'], self.opt.getMarkOpen(), data["tmovement"]]
-        self.WeldData = self.opt.calcPhaseGrow(self.idealTime[1])
 
     def _form_idealdatGraph(self):
 
@@ -147,6 +144,23 @@ class PlotWindow:
                     self._plotIdealData(np.array(time_data), np.array(item_data).T)
                     self._addBackgroundSplitter([item[1]*self.scaler,item[1]*self.scaler + time], color_closure)
                 
+                elif key == 'welding':
+                    x = [time_data[0], time_data[-1], time_data[-1]+0.0001]
+                    y = [item_data[0][4], item_data[0][4], item_data[0][4]]
+                    a1, b1, c1 = self._calculate_equidistant(x, y, 0.75, 3)
+                    self.p11.addItem(a1)
+                    self.p11.addItem(b1)
+                    self.p11.addItem(c1)
+                    
+                elif key == 'compression':
+                    temp = item_data[-1][4]
+                    x = [time_data[0], time_data[-1], time_data[-1]+0.0001]
+                    y = [temp, temp, temp]
+                    a1, b1, c1 = self._calculate_equidistant(x, y, 2.5, 3)
+                    self.p11.addItem(a1)
+                    self.p11.addItem(b1)
+                    self.p11.addItem(c1)     
+
     def _returnWeldData(self, _):
         return self.WeldData
 
@@ -207,17 +221,6 @@ class PlotWindow:
         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
@@ -227,11 +230,7 @@ class PlotWindow:
         return eq1, eq2, bg
 
 
-    def _calculate_equidistant(self, x, y, percent, splitter, color):
+    def _calculate_equidistant(self, x, y, percent, 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
@@ -241,19 +240,17 @@ class PlotWindow:
         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
             
-                dx = x[i + 1] - x[i]
+            nx = -sinA*distance
-                dy = y[i + 1] - y[i]
+            ny = sinB*distance
-                length = np.sqrt(dx ** 2 + dy ** 2)
+            x_eq1.append(x[i] + nx)
-                sinA = dy/length
+            y_eq1.append(y[i] + ny)
-                sinB = dx/length
+            x_eq2.append(x[i] - nx)
-                
+            y_eq2.append(y[i] - ny)
-                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/uml/creator.py

@@ -14,7 +14,7 @@ class UMLCreator:
             for key, items in self.timings_dict.items():
                 if key == 'closure': ideal_time = self._ideal_time[0]
                 elif key == 'compression': ideal_time = self._ideal_time[1]
-                elif key == 'welding': self.WeldTime
+                elif key == 'welding': ideal_time = self.WeldTime
                 elif key == 'opening': ideal_time = self._ideal_time[2]
                 
                 for item in items:
@@ -23,9 +23,23 @@ class UMLCreator:
                     
                     ideal_data.append([item[0]*self.scaler+0.0001, str(key) + '#yellow'])
                     ideal_data.append([(item[0]+ideal_time)*self.scaler, '{-}'])
+                    if key == 'opening':
+                        ideal_data.append([item[1]*self.scaler+0.0001, 'coming #yellow'])
+                        ideal_data.append([(item[1]+self._ideal_time[3])*self.scaler, '{-}'])
 
         else: 
             real_data = []
+            ideal_data = [
+                [0.0, 'closure #yellow'],
+                [self._ideal_time[0] * self.scaler, '{-}'],
+                [(self._ideal_time[0] + 0.0001) * self.scaler, 'compression #yellow'],
+                [sum(self._ideal_time[:2]) * self.scaler, '{-}'],
+                [(sum(self._ideal_time[:2])+ 0.0001) * self.scaler, 'welding #yellow'],
+                [(sum(self._ideal_time[:2]) + self.WeldTime)*self.scaler, '{-}'],
+                [(sum(self._ideal_time[:2]) + 0.0001 + self.WeldTime) * self.scaler, 'opening #yellow'],
+                [(sum(self._ideal_time[:3]) + self.WeldTime) * self.scaler, 'coming #yellow'],
+                [(sum(self._ideal_time[:4]) + self.WeldTime) * self.scaler, '{-}'],
+            ]
 
         client_data = [
             [0.0 * self.scaler, 'closure'],
@@ -38,43 +52,34 @@ class UMLCreator:
             [0.300 * self.scaler, '{-}'],
         ]
 
-        ideal_data = [
+        
-            [0.0 * self.scaler, 'closure #yellow'],
-            [self._ideal_time[0] * self.scaler, '{-}'],
-            [(self._ideal_time[0] + 0.0001) * self.scaler, 'compression #yellow'],
-            [(self._ideal_time[0] + self._ideal_time[1]) * self.scaler, '{-}'],
-            [(self._ideal_time[0] + self._ideal_time[1]+ 0.0001) * self.scaler, 'welding #yellow'],
-            [(self._ideal_time[0] + self._ideal_time[1] + self.WeldTime)*self.scaler, '{-}'],
-            [(self._ideal_time[0] + self._ideal_time[1] + 0.0001 + self.WeldTime) * self.scaler, 'opening #yellow'],
-            [(self._ideal_time[0] + self._ideal_time[1] + self._ideal_time[2] + self.WeldTime) * self.scaler, '{-}'],
-        ]
         return real_data, client_data, ideal_data, self.bool_dict
 
     def _generate_svg(self, real_data, client_data, ideal_data, bool_data) -> None:
+        
+        self._request_generator.clear()
+        self._request_generator.appendStr('scale 25 as 50 pixels')
+        
+        if not self.theor_mode:
+            self._request_generator.addLineStyle('biba', 'red', 2)
+
+            for i, [signal, changes] in enumerate(bool_data.items()):
+                name = 'bool_' + str(i)
+                times = []
+                for f in changes:
+                    times.append([str(float(f[0])*self.scaler), f[1]])
+                self._request_generator.addBinary(name, str(signal), 'biba')
+                self._request_generator.setTimestamps(name, times)
+
+            self._request_generator.addConcise('RD', 'Real data')
+            self._request_generator.setTimestamps('RD', real_data)
+
+        self._request_generator.addConcise('CD', 'Client data')
+        self._request_generator.setTimestamps('CD', client_data)
+        self._request_generator.addConcise('ID', 'Ideal data')
+        self._request_generator.setTimestamps('ID', ideal_data)
         try:    
-            self._request_generator.clear()
-            
-            if not self.theor_mode:
-                self._request_generator.addLineStyle('biba', 'red', 2)
-
-                for i, [signal, changes] in enumerate(bool_data.items()):
-                    name = 'bool_' + str(i)
-                    times = []
-                    for f in changes:
-                        times.append([str(float(f[0])*self.scaler), f[1]])
-                    self._request_generator.addBinary(name, str(signal), 'biba')
-                    self._request_generator.setTimestamps(name, times)
-
-                self._request_generator.addConcise('RD', 'Real data')
-                self._request_generator.setTimestamps('RD', real_data)
-
-            self._request_generator.addConcise('CD', 'Client data')
-            self._request_generator.setTimestamps('CD', client_data)
-            self._request_generator.addConcise('ID', 'Ideal data')
-            self._request_generator.setTimestamps('ID', ideal_data)
-
             self._request_generator.generateSVG()
-
         except Exception as e:
             print(f"SVG generate error: {e}")
 
@@ -95,6 +100,5 @@ class UMLCreator:
         self.scaler = int(system_config['UML_time_scaler'])
         self.WeldTime = operator_config['time_wielding']
         
-        
         real, client, ideal, bool_ = self._build_data()
         self._generate_svg(real, client, ideal, bool_)

src/uml/request_generator.py

@@ -78,7 +78,6 @@ class Request:
             self.reqArr.append('}')
 
         self.reqArr.append('</style>')
-        self.reqArr.append('scale 10 as 50 pixels')
 
     def _addVariables(self):
         for var in self.variables: self.reqArr.append(str(var))