def: добавлена возможность отрисовывать несколько точек подряд

params/operator_params.json

@@ -1,16 +1,16 @@
 {
-    "dist_open_start_1" : 0.005,
+    "dist_open_start_1": 0.005,
-    "dist_open_start_2" : 0.005,
+    "dist_open_start_2": 0.005,
-    "dist_open_after_1" : 0.006,
+    "dist_open_after_1": 0.006,
-    "dist_open_after_2" : 0.006,
+    "dist_open_after_2": 0.006,
-    "dist_open_end_1" : 0.010,
+    "dist_open_end_1": 0.01,
-    "dist_open_end_2" : 0.050,
+    "dist_open_end_2": 0.05,
-    "dist_close_end_1" : 0.005,
+    "dist_close_end_1": 0.005,
-    "dist_close_end_2" : 0.005,
+    "dist_close_end_2": 0.005,
-    "time_wielding" : 1,
+    "time_wielding": 1,
-    "time_command" : 0.060,
+    "time_command": 0.06,
-    "time_robot_movement" : 0.2,
+    "time_robot_movement": 0.2,
-    "object_thickness" : 4.5e-3,
+    "object_thickness": 0.0045,
-    "force_target" : 5000,
+    "force_target": 5000,
-    "force_capture" : 500
+    "force_capture": 500
 }

src/gui/app.py

@@ -21,7 +21,9 @@ class app:
         self.system_params = read_json("params/system_params.json")
 
         self.parser = DiagramParser(system_config=self.system_params)
-        self.parser.setData("trace_samples/2024_11_08-19_30_52.csv")
+        self.parser.setData("")
+        #trace_samples/2024_11_08-19_30_52.csv
+        
 
         self.opt_algorithm = OptAlgorithm(operator_config=self.operator_params, system_config=self.system_params)
         generator = Request(server_url='http://www.plantuml.com/plantuml/svg/')
@@ -62,7 +64,7 @@ class app:
         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,
+        self.uml_creator.update_uml(operator_config=self.system_params,
                                 ideal_time=self.ideal_times,
                                 bool_dict=self.bool_dict,
                                 float_dict=self.float_dict,

src/gui/plot_window.py

@@ -88,62 +88,68 @@ class PlotWindow:
         self.p13.clear()
         self.l13.clear()
 
-        if self.theor_mode:
+        if not self.theor_mode:
-            timings = np.arange(20000)/10
+            self._plotRealData()
-        else:
+        self._form_idealdatGraph()
-            timings = self._plotRealData()
-        self._plotIdealData(timings)
 
     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, times):
+    def _form_idealdatGraph(self):
 
         if self.theor_mode:
-            closure_start = 0 
+            self.timings_dict["closure"] = [[0, self.idealTime[0]]]
-            compression_start = self.idealTime[0]*self.scaler 
+            self.timings_dict["compression"] = [[self.idealTime[0], sum(self.idealTime[:2])]]
-            welding_start = sum(self.idealTime[:2])*self.scaler 
+            self.timings_dict["welding"] = [[sum(self.idealTime[:2]), sum(self.idealTime[:2])+self.WeldTime]]
-            opening_start = (sum(self.idealTime[:2])+ self.WeldTime)*self.scaler 
+            self.timings_dict["opening"] = [[sum(self.idealTime[:2])+self.WeldTime, sum(self.idealTime[:3])+self.WeldTime]]
-            opening_end = (sum(self.idealTime[:3])+ self.WeldTime)*self.scaler
-        else:
-            closure_start = self.timings_dict["closure"][0]*self.scaler 
-            compression_start = self.timings_dict["compression"][0]*self.scaler 
-            welding_start = self.timings_dict["welding"][0]*self.scaler 
-            opening_start = self.timings_dict["opening"][0]*self.scaler 
-            opening_end = self.timings_dict["opening"][1]*self.scaler 
 
-        self.idealPhase0 = closure_start + (self.idealTime[0])*self.scaler                                                          #Подъезд
+        delta = 10 #points_per_ms
-        self.idealPhase1 = compression_start + (self.idealTime[1])*self.scaler                                       #Сжатие
+        for key, items in self.timings_dict.items():
-        self.idealPhase2 = welding_start + (self.WeldTime)*self.scaler                       #Сварка
+            if key == 'closure': 
-        self.idealPhase3 = opening_start + (self.idealTime[2])*self.scaler   #Разъезд
+                ideal_time = self.idealTime[0]
-        self.idealPhase4 = opening_end + (self.idealTime[3])*self.scaler                                    #Последнее смыкание  
+                calc = self.opt.calcPhaseClose
+                color = qts.RGBA[0]
+            elif key == 'compression': 
+                ideal_time = self.idealTime[1]
+                calc = self.opt.calcPhaseGrow
+                color = qts.RGBA[1]
+            elif key == 'welding': 
+                ideal_time = self.WeldTime
+                calc = self._returnWeldData
+                color = qts.RGBA[2]
+            elif key == 'opening': 
+                calc = self.opt.calcPhaseOpen
+                ideal_time = self.idealTime[2]
+                ideal_closure = self.idealTime[3]
+                color = qts.RGBA[3]
+                color_closure = qts.RGBA[4]
+
+            for item in items:
+                item_data = []
+                time_data = []
+                for i in range(0, int(ideal_time*self.scaler)*delta):
+                    time = i/delta
+                    item_data.append(calc(time/self.scaler))
+                    time_data.append(time+item[0]*self.scaler)
+                    #print (item_data[-1], time_data[-1])
+                self._plotIdealData(np.array(time_data), np.array(item_data).T)
+                self._addBackgroundSplitter([item[0]*self.scaler,item[0]*self.scaler + time], color)
+                
+                if key == 'opening':
+                    item_data = []
+                    time_data = []
+                    for i in range(0, int(ideal_closure*self.scaler)*delta):
+                        time = i/delta
+                        item_data.append(self.opt.calcPhaseMovement(time/self.scaler))
+                        time_data.append(time+item[1]*self.scaler)
+                    self._plotIdealData(np.array(time_data), np.array(item_data).T)
+                    self._addBackgroundSplitter([item[1]*self.scaler,item[1]*self.scaler + time], color_closure)
+        
+    def _returnWeldData(self, _):
+        return self.WeldData
 
-        self.x_splitter = np.array([[closure_start, self.idealPhase0],
-             [compression_start, self.idealPhase1],
-             [welding_start, self.idealPhase2],
-             [opening_start, self.idealPhase3],
-             [opening_end, self.idealPhase4]])
-        data = []
-        for time in times:
-            if time >= closure_start and time <= self.idealPhase0:
-                x_fe, x_me, v_fe, v_me, f = self.opt.calcPhaseClose((time-closure_start)/self.scaler)
-            elif time >= compression_start and time <= self.idealPhase1:
-                x_fe, x_me, v_fe, v_me, f = self.opt.calcPhaseGrow((time-compression_start)/self.scaler)
-            elif time >= welding_start and time <= self.idealPhase2:
-                x_fe, x_me, v_fe, v_me, f = data[-1]
-            elif time >= opening_start and time <= self.idealPhase3:
-                x_fe, x_me, v_fe, v_me, f = self.opt.calcPhaseOpen((time-opening_start)/self.scaler)
-            elif time >= opening_end and time <= self.idealPhase4:
-                x_fe, x_me, v_fe, v_me, f = self.opt.calcPhaseMovement((time-opening_end)/self.scaler)
-            else:
-                if data:
-                    x_fe, x_me, v_fe, v_me, f = data[-1]
-                else: 
-                    x_fe, x_me, v_fe, v_me, f = 0,0,0,0,0
-            data.append([x_fe, x_me, v_fe, v_me, f])
-        data = np.array(data).T
-        return data
 
 
     def _plotRealData(self):
@@ -162,40 +168,37 @@ class PlotWindow:
                 self.l13.addItem(curve, key)
         return dat[0]
 
-    def _plotIdealData(self, times):
+    def _plotIdealData(self, time, data):
-        data = self._form_idealdatGraph(times)
+        x_fe = pg.PlotDataItem(time, data[0]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='x_fe', autoDownsample=True, downsample=True)
-
+        x_me = pg.PlotDataItem(time, data[1]*1000, pen=pg.mkPen(color=qts.colors[9], width=2), name='x_me', autoDownsample=True, downsample=True)
-        x_fe = pg.PlotDataItem(times, data[0]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='x_fe', autoDownsample=True, downsample=True)
+        v_fe = pg.PlotDataItem(time, data[2]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='v_fe', autoDownsample=True, downsample=True)
-        x_me = pg.PlotDataItem(times, data[1]*1000, pen=pg.mkPen(color=qts.colors[9], width=2), name='x_me', autoDownsample=True, downsample=True)
+        v_me = pg.PlotDataItem(time, data[3]*1000, pen=pg.mkPen(color=qts.colors[9], width=2), name='v_me', autoDownsample=True, downsample=True)
-        v_fe = pg.PlotDataItem(times, data[2]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='v_fe', autoDownsample=True, downsample=True)
+        f = pg.PlotDataItem(time, data[4], pen=pg.mkPen(color=qts.colors[8], width=2), name='f', autoDownsample=True, downsample=True)
-        v_me = pg.PlotDataItem(times, data[3]*1000, pen=pg.mkPen(color=qts.colors[9], width=2), name='v_me', autoDownsample=True, downsample=True)
-        f = pg.PlotDataItem(times, data[4], pen=pg.mkPen(color=qts.colors[8], width=2), name='f', autoDownsample=True, downsample=True)
 
         self.p11.addItem(f)
-        self.l11.addItem(f, 'Ideal force')
+        #self.l11.addItem(f, 'Ideal force')
 
         self.p12.addItem(x_fe)
-        self.l12.addItem(x_fe, 'FE POS')
+        #self.l12.addItem(x_fe, 'FE POS')
         self.p12.addItem(x_me)
-        self.l12.addItem(x_me, 'ME POS')
+        #self.l12.addItem(x_me, 'ME POS')
 
         self.p13.addItem(v_fe)
-        self.l13.addItem(v_fe, 'FE VEL')
+        #self.l13.addItem(v_fe, 'FE VEL')
         self.p13.addItem(v_me)
-        self.l13.addItem(v_me, 'ME VEL')
+        #self.l13.addItem(v_me, 'ME VEL')
-        self._addBackgroundSplitter()
+        #self._addBackgroundSplitter()
-        self._addEquidistances(times, data)
+        #self._addEquidistances(time, data)
 
-    def _addBackgroundSplitter(self):
+    def _addBackgroundSplitter(self, x, color):
         alpha = self.alpha
         y01 = np.array([10000, 10000])
         y0_1 = np.array([-10000, -10000])
-        for i, _ in enumerate(self.x_splitter):
+        a01 = pg.PlotDataItem(x, y01, pen=pg.mkPen(color=qts.colors[8], width=2), name=' ')
-            a01 = pg.PlotDataItem(_, y01, pen=pg.mkPen(color=qts.colors[8], width=2), name=' ')
+        a0_1 = pg.PlotDataItem(x, y0_1, 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, color+(alpha,))
-            bg1 = pg.FillBetweenItem(a01, a0_1, qts.RGBA[i]+(alpha,))
+        bg2 = pg.FillBetweenItem(a01, a0_1, color+(alpha,))
-            bg2 = pg.FillBetweenItem(a01, a0_1, qts.RGBA[i]+(alpha,))
+        bg3 = pg.FillBetweenItem(a01, a0_1, color+(alpha,))
-            bg3 = pg.FillBetweenItem(a01, a0_1, qts.RGBA[i]+(alpha,))
         self.p11.addItem(bg1)
         self.p12.addItem(bg2)
         self.p13.addItem(bg3)
@@ -216,8 +219,6 @@ class PlotWindow:
         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=1))

src/uml/creator.py

@@ -7,32 +7,22 @@ class UMLCreator:
 
 
     def _build_data(self):
+        real_data = []
+        ideal_data = []
         if not self.theor_mode:
-            closure = self.timings_dict["closure"]
-            compression = self.timings_dict["compression"]
-            welding = self.timings_dict["welding"]
-            opening = self.timings_dict["opening"]
-            real_data = [
-                [closure[0]*self.scaler, 'closure #green'],
-                [closure[1]*self.scaler, '{-}'],
-                [compression[0]*self.scaler+0.0001, 'compression #green'],
-                [compression[1]*self.scaler, '{-}'],
-                [welding[0]*self.scaler+0.0001, 'welding #green'],
-                [welding[1]*self.scaler, '{-}'],
-                [opening[0]*self.scaler+0.0001, 'opening  #green'],
-                [opening[1]*self.scaler, '{-}'],
-            ]
            
-            ideal_data = [
+            for key, items in self.timings_dict.items():
-            [closure[0] * self.scaler, 'closure #yellow'],
+                if key == 'closure': ideal_time = self._ideal_time[0]
-            [(self._ideal_time[0]+closure[0]) * self.scaler, '{-}'],
+                elif key == 'compression': ideal_time = self._ideal_time[1]
-            [compression[0] * self.scaler, 'compression #yellow'],
+                elif key == 'welding': self.WeldTime
-            [(compression[0] + self._ideal_time[1]) * self.scaler, '{-}'],
+                elif key == 'opening': ideal_time = self._ideal_time[2]
-            [welding[0] * self.scaler, 'welding #yellow'],
+                
-            [(welding[0] + self.WeldTime)*self.scaler, '{-}'],
+                for item in items:
-            [opening[0] * self.scaler, 'opening #yellow'],
+                    real_data.append([item[0]*self.scaler+0.0001, str(key) + '#green'])
-            [(opening[0] + self._ideal_time[2]) * self.scaler, '{-}'],
+                    real_data.append([item[1]*self.scaler, '{-}'])
-        ]
+                    
+                    ideal_data.append([item[0]*self.scaler+0.0001, str(key) + '#yellow'])
+                    ideal_data.append([(item[0]+ideal_time)*self.scaler, '{-}'])
 
         else: 
             real_data = []

src/utils/diagram_parser.py

@@ -28,10 +28,16 @@ class DiagramParser:
                 if type (self.data[signalName].iloc[0]) == np.float64:
                     self.floatDict[signalName] = self._getFloatChanges(signalName)
             
-            self.timingsDict["closure"] = [self.boolDict[self.signals[0]][1][0], self.boolDict[self.signals[0]][2][0]]
+            for key, items in self.boolDict.items():
-            self.timingsDict["compression"] = [self.boolDict[self.signals[1]][1][0], self.boolDict[self.signals[1]][2][0]]
+                if key == self.signals[0]: name = "closure"
-            self.timingsDict["welding"] = [self.boolDict[self.signals[2]][1][0], self.boolDict[self.signals[2]][2][0]]
+                elif key == self.signals[1]: name =  "compression"
-            self.timingsDict["opening"] = [self.boolDict[self.signals[3]][1][0], self.boolDict[self.signals[3]][2][0]]
+                elif key == self.signals[2]: name =  "welding"
+                elif key == self.signals[3]: name =  "opening"
+
+                self.timingsDict[name] = []
+                for i, item in enumerate(items):
+                    if item[1] == 'high':
+                        self.timingsDict[name].append([items[i][0], items[i+1][0]])
         
     def getBoolDict (self) -> dict:
         return self.boolDict