dev: производительность теперь считается по циклу всей детали. изменены цвета

params/operator_params.json

@@ -342,6 +342,36 @@
 
         0.507
 
+    ],
+    "Tesla summary time": [
+        1.824,
+        0.516,
+        2.160,
+        0.492,
+        2.160,
+        0.636,
+        1.908,
+        0.492,
+        1.788,
+        0.420,
+        1.800,
+        0.540,
+        1.812,
+        0.444,
+        1.884,
+        0.660,
+        1.884,
+        0.521,
+        1.848,
+        0.557,
+        1.848,
+        0.510,
+        1.860,
+        0.510,
+        1.908,
+        0.534,
+        1.908
     ]
 
+
 }

src/controller/passportFormer.py

@@ -56,8 +56,10 @@ class PassportFormer(BasePointPassportFormer):
                 else: 
                     frame = dataframe
                 point_events = {key: [value[0][i], value[1][i]] for key, value in events.items()}
-                tesla_events = sum([operator_settings[key] for key in self._tesla_stages])
+                # TODO: определить время каждого цикла теслы
-                passports_pocket.append([frame, ideal_data, point_events, tesla_events])
+                tesla_time = sum(self._params[0]["Tesla summary time"])
+                #tesla_events = sum([operator_settings[key] for key in self._tesla_stages])
+                passports_pocket.append([frame, ideal_data, point_events, tesla_time])
         return passports_pocket
 
     def update_settings(self, params: list[dict, dict]):

src/gui/plotter.py

@@ -28,11 +28,12 @@ class PlotWidget(BasePlotWidget):
     def _create_stage_region(self,
                              stage: str,
                              start_timestamp: float,
-                             finish_timestamp: float) -> Optional[pg.LinearRegionItem]:
+                             finish_timestamp: float,
+                             transparency:int) -> Optional[pg.LinearRegionItem]:
 
         if start_timestamp and finish_timestamp:
             region = pg.LinearRegionItem([start_timestamp, finish_timestamp], movable=False)
-            region.setBrush(pg.mkBrush(self._stage_colors[stage]))
+            region.setBrush(pg.mkBrush(self._stage_colors[stage][:3] + [transparency]))
             return region
         return None
 
@@ -73,7 +74,11 @@ class PlotWidget(BasePlotWidget):
             plot_widget, legend = self._init_plot_widget(title=channel)
             settings = description["Settings"]
 
-            for dataframe, ideal_data, events, tesla_data in data:
+            if settings["performance"]:
+                TWC_time = 0
+                ideal_time = 0
+
+            for cur_point, (dataframe, ideal_data, events, tesla_time) in enumerate(data):
                 df_continuous = pd.concat([df_continuous, dataframe], axis=0)
                 dataframe_headers = dataframe.columns.tolist()
                 stages = events.keys()
@@ -81,24 +86,30 @@ class PlotWidget(BasePlotWidget):
                 if settings["stages"] and all([stage in dataframe_headers for stage in stages]):
                     for stage in stages:
                         start_t, end_t = events[stage]
-                        region = self._create_stage_region(stage, start_t, end_t)
+                        region = self._create_stage_region(stage, start_t, end_t, 75)
                         if region:
                             plot_widget.addItem(region)
 
                 if settings["ideals"]:
-                    for stage in stages:
+                    for i, stage in enumerate(stages):
+                        start_t, _ = events[stage]
+                        end_t = start_t + ideal_data["Ideal timings"][i]
+                        region = self._create_stage_region(stage, start_t, end_t, 125)
+                        if region:
+                            plot_widget.addItem(region)
                         for signal in description["Ideal_signals"]:
                             curve = self._create_curve_ideal(signal, ideal_data[stage], events[stage][0], events[stage][1])
                             if curve:
                                 plot_widget.addItem(curve)
 
                 if settings["performance"]:
-                    ideal_delta = ideal_data["Ideal cycle"]
+                    if cur_point == len(data) -1:
-                    delta = 0
+                        ideal_time += sum(ideal_data["Ideal timings"][0:3])
-                    for stage in stages:
+                        TWC_time += sum([events[stage][1] - events[stage][0] for stage in ["Closing", "Squeeze", "Welding"]])
-                        delta += events[stage][1] - events[stage][0]
+                    else:
-                    performance = ideal_delta/delta*100
+                        for stage in stages:
-                    performance_list.append(performance)
+                            TWC_time += events[stage][1] - events[stage][0]
+                        ideal_time += ideal_data["Ideal cycle"]
 
                 if settings["zoom"]:
                     pass
@@ -147,27 +158,11 @@ class PlotWidget(BasePlotWidget):
                     legend.addItem(plot, signal["name"])
 
             if settings["performance"]:
-                performance_list = np.array(performance_list)
+                tesla_TWC = round((1 - TWC_time/tesla_time)*100,2)
-                performance_label = QLabel(f"""Performance: best = {round(performance_list.max(),2)} %, worse = {round(performance_list.min(),2)} %, average = {round(performance_list.mean(),2)}%""")
+                tesla_ideal = round((1 - ideal_time/tesla_time)*100,2)
-            
+                TWC_ideal = round((TWC_time/ideal_time - 1)*100,2)
-                TWC_start = 0
+                performance_label = QLabel(f"Сокращение длительности: фактическое = {tesla_TWC} %, идеальное = {tesla_ideal} %, разница идеала и факта = {TWC_ideal}%")
-                TWC_len = df_continuous["time"].max()
-                TWC_region = QGraphicsRectItem(TWC_start, -1000, TWC_start+TWC_len, 100)
-                TWC_region.setBrush(pg.mkBrush(0, 255, 0, 255))
-
-                tesla_start = 0
-                tesla_len = 35.488
-                tesla_reginon = QGraphicsRectItem(tesla_start, -1100, tesla_start+tesla_len ,100)
-                tesla_reginon.setBrush(pg.mkBrush(255, 0, 0, 255))
-
-                time_reduction = round((1 - TWC_len/tesla_len)*100, 2)
-                time_reduction_label = QLabel(f"Time reduction: {time_reduction} %")
-
                 layout.addWidget(performance_label)
-                layout.addWidget(time_reduction_label)
-                plot_widget.addItem(TWC_region)
-                plot_widget.addItem(tesla_reginon)
-
             layout.addWidget(plot_widget)
 
         widget.setLayout(layout)

src/utils/base/base.py

@@ -114,9 +114,9 @@ class BasePlotWidget:
         self._stage_colors = {
             "Closing": [208, 28, 31, 100],
             "Squeeze": [45, 51, 89, 150],
-            "Welding": [247, 183, 24, 100],
+            "Welding": [64, 64, 64, 100],
             "Relief": [0, 134, 88, 100],
-            "Oncomming": [222, 184, 135, 100]
+            "Oncomming": [255, 79, 0, 100]
         }
         self._plt_channels = {
             "Electrode Force, N & Welding Current, kA": {
@@ -394,7 +394,8 @@ class BasePointPassportFormer:
             "Welding": self._opt.get_weldingDF(),
             "Relief": self._opt.get_openingDF(), 
             "Oncomming": self._opt.get_oncomingDF(),
-            "Ideal cycle": self._opt.get_cycle_time()
+            "Ideal cycle": self._opt.get_cycle_time(),
+            "Ideal timings": self._opt.get_ideal_timings()
         }
         return stage_ideals