def: добавлена возможность отрисовывать несколько точек подряд
This commit is contained in:
Andrew
parent
b6b7de2fcb
commit
8ad4fdd355
@ -1,16 +1,16 @@
|
||||
{
|
||||
"dist_open_start_1" : 0.005,
|
||||
"dist_open_start_2" : 0.005,
|
||||
"dist_open_after_1" : 0.006,
|
||||
"dist_open_after_2" : 0.006,
|
||||
"dist_open_end_1" : 0.010,
|
||||
"dist_open_end_2" : 0.050,
|
||||
"dist_close_end_1" : 0.005,
|
||||
"dist_close_end_2" : 0.005,
|
||||
"time_wielding" : 1,
|
||||
"time_command" : 0.060,
|
||||
"time_robot_movement" : 0.2,
|
||||
"object_thickness" : 4.5e-3,
|
||||
"force_target" : 5000,
|
||||
"force_capture" : 500
|
||||
"dist_open_start_1": 0.005,
|
||||
"dist_open_start_2": 0.005,
|
||||
"dist_open_after_1": 0.006,
|
||||
"dist_open_after_2": 0.006,
|
||||
"dist_open_end_1": 0.01,
|
||||
"dist_open_end_2": 0.05,
|
||||
"dist_close_end_1": 0.005,
|
||||
"dist_close_end_2": 0.005,
|
||||
"time_wielding": 1,
|
||||
"time_command": 0.06,
|
||||
"time_robot_movement": 0.2,
|
||||
"object_thickness": 0.0045,
|
||||
"force_target": 5000,
|
||||
"force_capture": 500
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
@ -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,
|
||||
|
||||
@ -88,62 +88,68 @@ class PlotWindow:
|
||||
self.p13.clear()
|
||||
self.l13.clear()
|
||||
|
||||
if self.theor_mode:
|
||||
timings = np.arange(20000)/10
|
||||
else:
|
||||
timings = self._plotRealData()
|
||||
self._plotIdealData(timings)
|
||||
if not self.theor_mode:
|
||||
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, times):
|
||||
def _form_idealdatGraph(self):
|
||||
|
||||
if self.theor_mode:
|
||||
closure_start = 0
|
||||
compression_start = self.idealTime[0]*self.scaler
|
||||
welding_start = sum(self.idealTime[:2])*self.scaler
|
||||
opening_start = (sum(self.idealTime[:2])+ self.WeldTime)*self.scaler
|
||||
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.timings_dict["closure"] = [[0, self.idealTime[0]]]
|
||||
self.timings_dict["compression"] = [[self.idealTime[0], sum(self.idealTime[:2])]]
|
||||
self.timings_dict["welding"] = [[sum(self.idealTime[:2]), sum(self.idealTime[:2])+self.WeldTime]]
|
||||
self.timings_dict["opening"] = [[sum(self.idealTime[:2])+self.WeldTime, sum(self.idealTime[:3])+self.WeldTime]]
|
||||
|
||||
self.idealPhase0 = closure_start + (self.idealTime[0])*self.scaler #Подъезд
|
||||
self.idealPhase1 = compression_start + (self.idealTime[1])*self.scaler #Сжатие
|
||||
self.idealPhase2 = welding_start + (self.WeldTime)*self.scaler #Сварка
|
||||
self.idealPhase3 = opening_start + (self.idealTime[2])*self.scaler #Разъезд
|
||||
self.idealPhase4 = opening_end + (self.idealTime[3])*self.scaler #Последнее смыкание
|
||||
delta = 10 #points_per_ms
|
||||
for key, items in self.timings_dict.items():
|
||||
if key == 'closure':
|
||||
ideal_time = self.idealTime[0]
|
||||
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):
|
||||
data = self._form_idealdatGraph(times)
|
||||
|
||||
x_fe = pg.PlotDataItem(times, data[0]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='x_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_fe = pg.PlotDataItem(times, data[2]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='v_fe', 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)
|
||||
def _plotIdealData(self, time, data):
|
||||
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)
|
||||
v_fe = pg.PlotDataItem(time, data[2]*1000, pen=pg.mkPen(color=qts.colors[8], width=2), name='v_fe', 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)
|
||||
f = pg.PlotDataItem(time, 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._addBackgroundSplitter()
|
||||
self._addEquidistances(times, data)
|
||||
#self.l13.addItem(v_me, 'ME VEL')
|
||||
#self._addBackgroundSplitter()
|
||||
#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(_, 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,))
|
||||
bg2 = pg.FillBetweenItem(a01, a0_1, qts.RGBA[i]+(alpha,))
|
||||
bg3 = pg.FillBetweenItem(a01, a0_1, qts.RGBA[i]+(alpha,))
|
||||
a01 = pg.PlotDataItem(x, 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=' ')
|
||||
bg1 = pg.FillBetweenItem(a01, a0_1, color+(alpha,))
|
||||
bg2 = pg.FillBetweenItem(a01, a0_1, color+(alpha,))
|
||||
bg3 = pg.FillBetweenItem(a01, a0_1, color+(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))
|
||||
|
||||
Binary file not shown.
@ -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 = [
|
||||
[closure[0] * self.scaler, 'closure #yellow'],
|
||||
[(self._ideal_time[0]+closure[0]) * self.scaler, '{-}'],
|
||||
[compression[0] * self.scaler, 'compression #yellow'],
|
||||
[(compression[0] + self._ideal_time[1]) * self.scaler, '{-}'],
|
||||
[welding[0] * self.scaler, 'welding #yellow'],
|
||||
[(welding[0] + self.WeldTime)*self.scaler, '{-}'],
|
||||
[opening[0] * self.scaler, 'opening #yellow'],
|
||||
[(opening[0] + self._ideal_time[2]) * self.scaler, '{-}'],
|
||||
]
|
||||
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 == 'opening': ideal_time = self._ideal_time[2]
|
||||
|
||||
for item in items:
|
||||
real_data.append([item[0]*self.scaler+0.0001, str(key) + '#green'])
|
||||
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 = []
|
||||
|
||||
Binary file not shown.
@ -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]]
|
||||
self.timingsDict["compression"] = [self.boolDict[self.signals[1]][1][0], self.boolDict[self.signals[1]][2][0]]
|
||||
self.timingsDict["welding"] = [self.boolDict[self.signals[2]][1][0], self.boolDict[self.signals[2]][2][0]]
|
||||
self.timingsDict["opening"] = [self.boolDict[self.signals[3]][1][0], self.boolDict[self.signals[3]][2][0]]
|
||||
for key, items in self.boolDict.items():
|
||||
if key == self.signals[0]: name = "closure"
|
||||
elif key == self.signals[1]: name = "compression"
|
||||
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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user