chore: линии идеального графика объеденены с разрывами в один объект

params/plot_structure_params.json

@@ -286,7 +286,7 @@
                     "pen": "g"
                 },
                 {
-                    "name": "Electrode Speed, mm ME",
+                    "name": "Rotor Speed, mm/s ME",
                     "pen": "b"
                 },
                 {

src/controller/passport_former.py

@@ -177,6 +177,7 @@ class PassportFormer(BasePointPassportFormer):
             for i in range(point_quantity):
                 point_settings = Settings(self._get_operator_settings_part(i), system_settings)
                 timeframe, po_events = self._form_point_events(events, i)
+                if timeframe and po_events:
                     point_settings.operator["time_robot_movement"] = po_events["Oncomming"][1] - po_events["Oncomming"][0]
                 ideal_data = self._form_point_ideal_data(point_settings)
                 useful_data = self._form_point_useful_data(point_settings.operator)

src/gui/plotter.py

@@ -17,6 +17,7 @@ from PyQt5.QtCore import Qt
 from loguru import logger
 import pyqtgraph as pg
 import pandas as pd
+import numpy as np
 
 from base.base import BasePlotWidget, GraphicPassport, PlotItems, PointPassport, UsefulGraphData, BaseController
 from utils.json_tools import read_json
@@ -78,13 +79,10 @@ class PlotWidget(BasePlotWidget):
         match mode:
             case 1:
                 self._plt_channels = self._plt_structures["Online Path Scanner"]
-                print (1)
             case 2: 
                 self._plt_channels = self._plt_structures["Report Editor"]
-                print (2)
             case 3: 
                 self._plt_channels = self._plt_structures["Client Trace Watcher"]      
-                print(3)     
 
     def _build_raw_plotitem(self, 
                             data:list[pd.DataFrame, dict], 
@@ -104,7 +102,6 @@ class PlotWidget(BasePlotWidget):
             for key, item in events.items():
                 point_events[key] = [item[0][i], item[1][i]]
                 PlotItemGenerator._add_stage_regions(self._stage_colors, plot_item, point_events, pyqt_container.regions,20)
-            print(point_events)
 
         plot_layout = pg.GraphicsLayoutWidget()
         plot_layout.addItem(plot_item)
@@ -120,7 +117,6 @@ class PlotWidget(BasePlotWidget):
         tesla_TWC = round((1 - timings.TWC_time/timings.client_time)*100, 2) if timings.client_time else 0.0
         tesla_ideal = round((1 - timings.ideal_time/timings.client_time)*100, 2) if timings.client_time else 0.0
         TWC_ideal = round((timings.ideal_time/timings.TWC_time)*100, 2) if timings.TWC_time else 0.0
-        print(timings.client_time, timings.TWC_time)
         label_widget = QWidget()
         label_layout = QHBoxLayout(label_widget)
         start_label = QLabel("Сокращение длительности: ")
@@ -254,6 +250,8 @@ class PlotItemGenerator:
         timings = ChannelTimings()
         timings.client_time = useful_data.client_time
 
+        ideal_df = pd.DataFrame({})
+
         # TODO: рассчитать корректный параметр range 
         if settings.get("mirror ME", False) and not self._ideal_mode:
             dataframe = self._shift_data(
@@ -295,7 +293,7 @@ class PlotItemGenerator:
 
             if settings.get("ideals", False):
                 self._add_ideal_stage_regions(self._stage_colors, plot_item, ideal_data, point_data.events, pyqt_container.regions, 100)
-                self._add_ideal_signals(plot_item, legend, ideal_data, point_data.events, description["Ideal_signals"], pyqt_container.curves, is_last)
+                ideal_df = self._modify_ideal_df(ideal_df, ideal_data, point_data.events)
 
             if settings.get("performance", False):
                 timings = self._calc_performance(timings, point_data, ideal_data, is_first, is_last)
@@ -303,8 +301,11 @@ class PlotItemGenerator:
             self._parent._update_status(widget_steps, point_steps, widget_num, cur_point)
 
         # Добавляем реальные сигналы
+        if settings.get("ideals", False):
+            self._add_signals(plot_item, ideal_df, description["Ideal_signals"], legend, pyqt_container.curves["ideal"])
+
         if not self._ideal_mode:
-            self._add_real_signals(plot_item, dataframe, description["Real_signals"], legend, pyqt_container.curves)
+            self._add_signals(plot_item, dataframe, description["Real_signals"], legend, pyqt_container.curves["real"])
         return (plot_item, timings)
     
     @staticmethod
@@ -315,7 +316,7 @@ class PlotItemGenerator:
         keys = dataframe.keys()
         for signal in signals:
             if valid_str in signal["name"] and signal["name"] in keys:
-                dataframe[signal["name"]] = dataframe[signal["name"]].apply(func )
+                dataframe[signal["name"]] = dataframe[signal["name"]].apply(func)
         return dataframe
 
     @staticmethod
@@ -402,34 +403,26 @@ class PlotItemGenerator:
                 reg_items["ideal"].setdefault(stage, [])
                 reg_items["ideal"][stage].append(region) 
 
-    def _add_ideal_signals(self,
+    def _modify_ideal_df(self,
-                           plot_item: pg.PlotItem,
+                        ideal_df: pd.DataFrame,
-                           legend_item: pg.LegendItem,
                         ideal_data: dict[str, Any],
-                           point_events: dict[str, list[float]],
+                        point_events: dict[str, list[float]]) -> None:
-                           ideal_signals: list[dict[str, Any]], 
-                           curve_items: dict,
-                           is_last: bool) -> None:
         """
         Добавляет идеальные сигналы для каждого этапа.
         """
-        for signal in ideal_signals:
         for stage in point_events.keys():
-                curve = self._create_curve_ideal(
+            if not ideal_df.empty:
-                    signal,
+                last_time = ideal_df['time'].iloc[-1]
-                    ideal_data[stage],
+                separator_row = {col: np.nan if col != "time" else last_time + 0.01 for col in ideal_df.columns}
-                    point_events[stage][0],
+                separator_df = pd.DataFrame([separator_row])
-                    point_events[stage][1]
+                worker_df = ideal_data[stage].copy(deep=True)
-                )
+                worker_df["time"] = worker_df["time"]+point_events[stage][0]
-                if curve:
+                ideal_df = pd.concat([ideal_df, separator_df, worker_df], ignore_index=True)
-                    curve.setZValue(50)
+            else: 
-                    plot_item.addItem(curve)
+                ideal_df = ideal_data[stage].copy()
-                    curve_items["ideal"].setdefault(signal["name"], {})
+        return ideal_df
-                    curve_items["ideal"][signal["name"]].setdefault(stage, [])
-                    curve_items["ideal"][signal["name"]][stage].append(curve)
-            if is_last: legend_item.addItem(curve, "Ideal " + signal["name"])
     
-    def _add_real_signals(self,
+    def _add_signals(self,
                           plot_item: pg.PlotItem,
                           dataframe: pd.DataFrame,
                           real_signals: list[dict[str, Any]],
@@ -444,8 +437,8 @@ class PlotItemGenerator:
                 plot = plot_item.plot(dataframe["time"], dataframe[signal["name"]], pen=signal["pen"], fast=True)
                 plot.setZValue(0)
                 legend.addItem(plot, signal["name"])
-                curve_items["real"].setdefault(signal["name"], {})
+                curve_items.setdefault(signal["name"], {})
-                curve_items["real"][signal["name"]] = plot
+                curve_items[signal["name"]] = plot
 
     @staticmethod
     def _update_plots_downsample(plot_item:pg.PlotItem):

src/gui/report_gui.py

@@ -90,7 +90,7 @@ class ReportSettings(QtWidgets.QWidget):
 
         res = {'name': 'Plots', 'type': 'group', 'children': [
                 {'name': 'Real plots', 'type': 'group', 'children': self._create_samples(curve_items["real"])},
-                {'name': 'Ideal plots', 'type': 'group', 'children': self._create_ideal_curves(curve_items["ideal"])},
+                {'name': 'Ideal plots', 'type': 'group', 'children': self._create_samples(curve_items["ideal"])},
             ]}
         return res
 
@@ -160,9 +160,7 @@ class ReportSettings(QtWidgets.QWidget):
         self._set_sector_settings(reg_items["ideal"], ideal_sectors)
 
         self._set_plot_settings(curve_items["real"], real_plots)
-        for key, item_dict in curve_items["ideal"].items():
+        self._set_plot_settings(curve_items["ideal"], ideal_plots)
-            self._set_plot_settings(item_dict, ideal_plots.child(key))
-
         self._set_qt_settings(qt_items, qt_settings)
 
     def _set_sector_settings(self,