def graphpoints(self, *args): hotendactual_plot = SmoothLinePlot(color=[1, 0, 0, 1]) hotendtarget_plot = MeshLinePlot(color=[1, 0, 0, .75]) bedactual_plot = SmoothLinePlot(color=[0, 0, 1, 1]) bedtarget_plot = MeshLinePlot(color=[0, 0, 1, .75]) #Build list of plot points tuples from temp and time lists ##FIXME - Need to reduce the number of points on the graph. 360 is overkill hotendactual_points_list = [] hotendtarget_points_list = [] bedactual_points_list = [] bedtarget_points_list = [] for i in range(360): hotendactual_points_list.append( (graphtime_list[i]/1000.0*-1, hotendactual_list[i]) ) hotendtarget_points_list.append( (graphtime_list[i]/1000.0*-1, hotendtarget_list[i]) ) bedactual_points_list.append( (graphtime_list[i]/1000.0*-1, bedactual_list[i]) ) bedtarget_points_list.append( (graphtime_list[i]/1000.0*-1, bedtarget_list[i]) ) #Remove all old plots from the graph before drawing new ones for plot in self.my_graph.plots: self.my_graph.remove_plot(plot) #Draw the new graphs hotendactual_plot.points = hotendactual_points_list self.my_graph.add_plot(hotendactual_plot) hotendtarget_plot.points = hotendtarget_points_list self.my_graph.add_plot(hotendtarget_plot) bedactual_plot.points = bedactual_points_list self.my_graph.add_plot(bedactual_plot) bedtarget_plot.points = bedtarget_points_list self.my_graph.add_plot(bedtarget_plot)
def __init__(self, **kwargs): super(BElGenLiveGraph, self).__init__(**kwargs) graph = Graph( xlabel="X", ylabel="Y", x_ticks_minor=5, x_ticks_major=25, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=-0, xmax=10, ymin=-12, ymax=12, ) plot = SmoothLinePlot(color=[0.49, 0.98, 1, 1]) with open("adclog.txt") as fh: coords = [] for line in fh: line = line.strip("()\n") # Get rid of the newline and parentheses line = line.split(", ") # Split into two parts c = tuple(float(x) for x in line) # Make the tuple coords.append(c) plot.points = coords graph.add_plot(plot) self.add_widget(graph)
def get_daily_cost(self): if self.flag == 1: return self.flag = 1 day_list = days_to_ints(get_all_days()) my_day_list = {} for (m, d) in day_list: if m in my_day_list: my_day_list[m].append(d) else: my_day_list[m] = [] my_day_list[m].append(d) new_day_list = [] for eachMonth in my_day_list: for eachDay in my_day_list[eachMonth]: new_day_list.append(eachDay + (eachMonth - 1) * 30) day_cost = get_daily_cost() points_list = self.make_pairs(new_day_list, day_cost) print(points_list) plot = SmoothLinePlot(color=[162 / 255.0, 121 / 255.0, 119 / 255.0, 1]) plot.points = points_list self.graph8.add_plot(plot) self.ids['graph1'].remove_widget(self.graph2) self.ids['graph1'].remove_widget(self.graph1) self.ids['graph1'].add_widget(self.graph8)
def __init__(self, n, S, C, t, I): """ Paramètres ---------- n : int Nombre d'électrons échangés au cours de la réaction. S : float Surface d'échange. C : float Concentration de l'espèce. t : list Tableau de valeurs des temps expérimentaux. I : list Tableau de valeurs des intensités mesurées expérimentalement. """ super(GraphLinearRegression, self).__init__(t, I) self.n = n self.S = S self.C = C graph_theme = { 'label_options': { 'color': [0, 0, 0, 1], # color of tick labels and titles 'bold': False }, 'background_color': [1, 1, 1, 1], # back ground color of canvas 'tick_color': [0, 0, 0, 1], # ticks and grid 'border_color': [0, 0, 0, 1] } # border drawn around each graph self.graph = Graph(title='Courbes de Regression lineaire', xlabel='log Temps (s)', ylabel='log Intensité (A)', x_ticks_minor=5, x_ticks_major=5, y_ticks_major=0.2, y_ticks_minor=4, y_grid_label=True, x_grid_label=True, padding=5, x_grid=False, y_grid=False, precision="%#.4g", **graph_theme) self.logexpplot = SmoothLinePlot(color=[1, 0, 0, 1]) self.logexpplot.label = "Expérimentale" self.linlogexpplot = SmoothLinePlot(color=[1, 0, 1, 1]) self.graph.legend = True self.graph.add_plot(self.logexpplot) self.graph.add_plot(self.linlogexpplot) self._trigger = Clock.create_trigger(self.update_ticks) self.graph._plot_area.bind(pos=self._trigger)
def desenha_eixos(self): # Desenho dos graficos self.eixo_x = SmoothLinePlot(color=[0, 1, 1, 1]) self.eixo_x.points = [(self.xmin, 0), (self.xmax, 0)] self.eixo_y = SmoothLinePlot(color=[0, 1, 1, 1]) self.eixo_y.points = [(0, self.ymin), (0, self.ymax)] # Exibindo os graficos self.propriedade_grafico.add_plot(self.eixo_x) self.propriedade_grafico.add_plot(self.eixo_y)
def build(self, name, color, before, after): self.name.text = name self.bplot = SmoothLinePlot(color=COLOR_GRAY) self.bplot.points = build_points(*before) self.graph.add_plot(self.bplot) self.aplot = SmoothLinePlot(color=color) self.aplot.points = build_points(*after) self.graph.add_plot(self.aplot)
def __init__(self, **kwargs): super(HomeScreen, self).__init__(**kwargs) self.temp_plot = SmoothLinePlot(color=[1, 0, 0, 1]) self.temp_set_plot = MeshLinePlot(color=[0.7, 0, 0, 1]) self.od_plot = SmoothLinePlot(color=[1, 0.5, 0, 1]) self.od_set_plot = MeshLinePlot(color=[0.7, 0.3, 0, 1]) self.led_plot = MeshLinePlot(color=[1, 1, 0, 1]) self.peltier_plot = MeshLinePlot(color=[1, 0, 0.5, 1]) self.stir_plot = MeshLinePlot(color=[0, 1, 0, 1]) self.mot_in_plot = MeshLinePlot(color=[0, 0, 1, 1]) self.mot_out_plot = MeshLinePlot(color=[0, 1, 1, 1])
def __init__(self, t=[], I=[]): """ Paramètres ---------- t : list Tableau de valeurs de temps. I : list Tableau de valeurs d'intensité. """ super(CottrellGraph, self).__init__(t, I) graph_theme = { 'label_options': { 'color': [0, 0, 0, 1], # color of tick labels and titles 'bold': False }, 'background_color': [1, 1, 1, 1], # back ground color of canvas 'tick_color': [0, 0, 0, 1], # ticks and grid 'border_color': [0, 0, 0, 1] } # border drawn around each graph self.graph = Graph(title='Courbes de Cottrell', xlabel='Temps (s)', ylabel='Intensité (A)', x_ticks_minor=5, x_ticks_major=5, y_ticks_major=0.2, y_ticks_minor=4, y_grid_label=self.ticks_labels, x_grid_label=self.ticks_labels, padding=5, x_grid=False, y_grid=False, xmin=float(self.tleft), xmax=float(self.tright), ymin=float(self.Ibottom), ymax=float(self.Itop), legend=self.legend, precision="%#.4g", **graph_theme) self.thplot = SmoothLinePlot(color=[0, 0, 1, 1]) self.thplot.label = "Théorique" self.expplot = SmoothLinePlot(color=[1, 0, 0, 1]) self.expplot.label = "Expérimentale" self.bind(legend=self.graph.setter('legend')) self.bind(ticks_labels=self.graph.setter('y_grid_label')) self.bind(ticks_labels=self.graph.setter('x_grid_label')) self._trigger = Clock.create_trigger(self.update_ticks) self.graph.bind(size=self._trigger) self.graph._plot_area.bind(pos=self._trigger)
def __init__(self,**kwargs): super(ReactorScreen4, self).__init__(**kwargs) self.name = "reactor4" Clock.schedule_once(self._finish_init) Clock.schedule_interval(self.get_value, 1) self.plot_temp = SmoothLinePlot(color = get_color_from_hex('#23C48E')) self.plot_humidity = SmoothLinePlot(color = get_color_from_hex('#04C0F8')) self.rangedict = ['No not', '12/10/1', '24'] self.y_axis_min = 0 self.y_axis_max = 100 self.time_duration = 2
def __init__(self,**kwargs): super(ReactorScreen1, self).__init__(**kwargs) self.name = "reactor1" global rangedict Clock.schedule_once(self._finish_init) Clock.schedule_interval(self.get_value, 0.7) self.plot_temp = SmoothLinePlot(color = get_color_from_hex('00FCC6')) self.plot_humidity = SmoothLinePlot(color = get_color_from_hex('00BFFF')) self.rangedict = ['No not', '12/10/1', '24'] self.y_axis_min = 0 self.y_axis_max = 100 self.time_duration = 2
def update_plot(self, event=False): profile_scrollview = self.get_widget(self, 'profile_scrollview') profile_gridlayout = self.get_widget(profile_scrollview, 'profile_gridlayout') box = self.get_widget(profile_gridlayout, 'box') profile_graph = self.get_widget(box, 'profile_graph') profile_plot = SmoothLinePlot(color=[1,0,0,1]) profile_plot.points = [(float(x[1][0]), float(x[1][1])) for x in self.current_profile_df.iterrows()] #(float(x[1][0]), float(x[1][1])) for x in self.current_profile_df.iterrows() # print profile_plot.points for plot in profile_graph.plots: profile_graph.remove_plot(plot) profile_graph.add_plot(profile_plot)
def update_plot(self, event=False): monitor_scrollview = self.get_widget(self, 'monitor_scrollview') monitor_gridlayout = self.get_widget(monitor_scrollview, 'monitor_gridlayout') box = self.get_widget(monitor_gridlayout, 'box') monitor_graph = self.get_widget(box, 'monitor_graph') profile_plot = SmoothLinePlot(color=[1,0,0,1]) profile_plot.points = [(float(x[1]['time']), float(x[1]['temperature'])) for x in self.unfilled_profile.iterrows()] #(float(x[1][0]), float(x[1][1])) for x in self.current_profile_df.iterrows() # brew_plot = SmoothLinePlot(color=[0,1,0,1]) # brew_plot.points = [(float(x[1][0]), float(x[1][1])) for x in self.brew_df.iterrows()] for plot in monitor_graph.plots: monitor_graph.remove_plot(plot) monitor_graph.add_plot(profile_plot)
def desenha_circulo(self, raio, centro_x): self.plot_circulo = SmoothLinePlot(color=[1, 0, 0, 1]) self.plot_circulo.points = [ (centro_x + raio * math.cos(theta * .01), raio * math.sin(theta * .01)) for theta in range(0, 1300) ] # 130 => 40*pi (para dar 2 voltas completas) self.propriedade_grafico.add_plot(self.plot_circulo)
def use_signals_config(self, signal_sources_config): self.graph_labels = [] self.history = SignalHistory() if 'history_max' in signal_sources_config: self.history.max_seconds = signal_sources_config['history_max'] if 'history_delta' in signal_sources_config: self.history.delta_seconds = signal_sources_config['history_delta'] self.plots = [] self.graph_visible = [] for group in signal_sources_config['groups']: group_label = group['label'] for source in group['sources']: self.graph_labels.append(group_label + ' ' + source.label) self.history.add_source(source) self.graph_visible.append(source.with_graph) plot = SmoothLinePlot(color=source.color) self.plots.append(plot) for source_plot in sorted(zip(self.history.sources, self.plots), key=lambda sp: sp[0].z_order): self.ids.graphs_canvas.add_plot(source_plot[1]) self.history.write_to_csv('csv/signals') self.history.load_from_csv_files() self.history.start() self.x_range = self.history.max_seconds self.x_max = None Clock.schedule_once(self.update_graphs, 0.)
def __init__(self, x=[], cox=[]): """ Paramètres ---------- x : list Tableau des distances à l'électrode. cox : list Tableau de la concentration. """ self.x = x self.cox = cox theme_cls = App.get_running_app().theme_cls graph_theme={} if App.get_running_app().theme == 'default': graph_theme = { 'label_options': { 'color': [0, 0, 0, 1], # color of tick labels and titles 'bold': False, 'markup': True}, 'background_color': [1, 1, 1, 1], # back ground color of canvas 'tick_color': [0, 0, 0, 1], # ticks and grid 'border_color': [0, 0, 0, 1]} # border drawn around each graph elif App.get_running_app().theme == 'material-design': graph_theme = { 'label_options': { 'color': get_color_from_hex(colors[theme_cls.primary_palette][theme_cls.primary_hue]),#[0, 0, 0, 1], # color of tick labels and titles 'bold': False, 'markup': True}, 'background_color': get_color_from_hex(colors[theme_cls.theme_style]["Background"]),#[1, 1, 1, 1], # back ground color of canvas 'tick_color': get_color_from_hex(colors[theme_cls.accent_palette][theme_cls.accent_hue]),#[0, 0, 0, 1], # ticks and grid 'border_color': get_color_from_hex(colors[theme_cls.accent_palette][theme_cls.accent_hue])}#[0, 0, 0, 1]} # border drawn around each graph self.graph = Graph(title = 'Courbe C[sub]ox[/sub]', xlabel='x', ylabel='C[sub]ox[/sub] / C[sup]*[/sup] [sub]ox[/sub]', x_ticks_minor=5, x_ticks_major=5, y_ticks_major=1, y_ticks_minor=4, y_grid_label=True, x_grid_label=True, padding=5, x_grid=False, y_grid=False, xmin=float(0), xmax=float(0.05), ymin=float(0), ymax=float(1), precision="%#.4g", **graph_theme) self.coxplot = SmoothLinePlot(color=[0, 0, 1, 1]) self.coxplot.label = "Concentration" self.graph.add_plot(self.coxplot) self._trigger = Clock.create_trigger(self.update_ticks) self.graph._plot_area.bind(pos=self._trigger)
def desenha_angulo(self, centro_x, raio): self.arco_angulo = SmoothLinePlot(color=[1, 1, 0, 1]) self.arco_angulo.points = [ (centro_x + 0.1 * raio * math.cos(theta * .1), 0.1 * raio * math.sin(theta * .1)) for theta in range(0, int(20 * self.angulo + 2)) ] self.propriedade_grafico.add_plot(self.arco_angulo)
def get_monthly_cost(self): if self.flag == 3: return self.flag = 3 month_list = get_all_months() month_cost = get_monthly_cost() points_list = self.make_pairs(month_list, month_cost) print(points_list) plot = SmoothLinePlot(color=[162 / 255.0, 121 / 255.0, 119 / 255.0, 1]) plot.points = points_list self.graph1.add_plot(plot) self.ids['graph1'].remove_widget(self.graph8) self.ids['graph1'].remove_widget(self.graph2) self.ids['graph1'].add_widget(self.graph1)
def get_weekly_cost(self): if self.flag == 2: return self.flag = 2 week_list = get_all_weeks() week_cost = get_weekly_cost() points_list = self.make_pairs(week_list, week_cost) print(points_list) plot = SmoothLinePlot(color=[162 / 255.0, 121 / 255.0, 119 / 255.0, 1]) plot.points = points_list self.graph2.add_plot(plot) self.ids['graph1'].remove_widget(self.graph8) self.ids['graph1'].remove_widget(self.graph1) self.ids['graph1'].add_widget(self.graph2)
def create_kivy_plot(self, series=np.array(range(12)), label_y='Average Response Time'): if self.graph_figure: self.destroy() series_len = len(series) if series_len == 0: return False max_y = max(series) min_y = min(series) #arg_max_y = series.index(max_y) # use this to label max and min... #arg_min_y = series.index(min_y) # with their resp time stamp ticks_y = round(max_y / 10., 2) graph_theme = { 'label_options': { 'color': rgb('444444'), # color of tick labels and titles 'bold': True }, 'background_color': rgb('000000'), # back ground color of canvas 'tick_color': rgb('444444'), # ticks and grid 'border_color': rgb('444444') } # border drawn around each graph self.graph_figure = Graph(xlabel='Last {} games'.format(series_len), ylabel=label_y, x_ticks_minor=5, x_ticks_major=5, y_ticks_major=ticks_y, y_grid_label=True, x_grid_label=True, padding=10, x_grid=False, y_grid=True, xmin=0, xmax=series_len, ymin=0, ymax=int(1.2 * max_y + 1), _with_stencilbuffer=False, **graph_theme) plot = SmoothLinePlot(color=next(self.colors)) #mode='line_strip', plot.points = [(x, series[x - 1]) for x in range(1, len(series) + 1)] self.graph_figure.add_plot(plot) self.add_widget(self.graph_figure)
def get_weekly_mistakes(self): if self.flag == 5: return self.flag = 5 week_list = get_all_weeks() week_om_cost = get_monthly_mistake_tuple()[0] week_cm_cost = get_monthly_mistake_tuple()[1] points_om_list = self.make_pairs(week_list, week_om_cost) points_cm_list = self.make_pairs(week_list, week_cm_cost) plot_om = SmoothLinePlot( color=[255 / 255.0, 125 / 255.0, 125 / 255.0, 1]) plot_om.points = points_om_list plot_cm = SmoothLinePlot( color=[125 / 255.0, 177 / 255.0, 255 / 255.0, 1]) plot_cm.points = points_cm_list # print("om:" + str(points_om_list)) #Blue # print("cm:" + str(points_cm_list)) # Red # week_mistakes = get_weekly_mistake_num() # points_list = self.make_pairs(week_list, week_mistakes) # print(points_list) plot = SmoothLinePlot(color=[1, 0, 0, 1]) self.graph6.add_plot(plot_om) self.graph6.add_plot(plot_cm) self.ids['graph3'].remove_widget(self.graph7) self.ids['graph3'].remove_widget(self.graph5) self.ids['graph3'].add_widget(self.graph6)
def __init__(self, **kwargs): super(BElGenLiveGraph, self).__init__(**kwargs) graph = Graph(xlabel='X', ylabel='Y', x_ticks_minor=5, x_ticks_major=25, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=-0, xmax=10, ymin=-12, ymax=12) plot = SmoothLinePlot(color=[0.49, 0.98, 1, 1]) with open("adclog.txt") as fh: coords = [] for line in fh: line = line.strip('()\n') line = line.split(', ') c = tuple(float(x) for x in line) coords.append(c) plot.points = coords graph.add_plot(plot) self.add_widget(graph)
def graphpoints(self, *args): hotendactual_plot = SmoothLinePlot(color=[1, 0, 0, 1]) hotendtarget_plot = MeshLinePlot(color=[1, 0, 0, .75]) bedactual_plot = SmoothLinePlot(color=[0, 0, 1, 1]) bedtarget_plot = MeshLinePlot(color=[0, 0, 1, .75]) # Build list of plot points tuples from temp and time lists # FIXME - Need to reduce the number of points on the graph. 360 is overkill hotendactual_points_list = [] hotendtarget_points_list = [] bedactual_points_list = [] bedtarget_points_list = [] for i in range(360): hotendactual_points_list.append( (graphtime_list[i] / 1000.0 * -1, hotendactual_list[i])) hotendtarget_points_list.append( (graphtime_list[i] / 1000.0 * -1, hotendtarget_list[i])) bedactual_points_list.append( (graphtime_list[i] / 1000.0 * -1, bedactual_list[i])) bedtarget_points_list.append( (graphtime_list[i] / 1000.0 * -1, bedtarget_list[i])) # Remove all old plots from the graph before drawing new ones for plot in self.my_graph.plots: self.my_graph.remove_plot(plot) # Draw the new graphs hotendactual_plot.points = hotendactual_points_list self.my_graph.add_plot(hotendactual_plot) hotendtarget_plot.points = hotendtarget_points_list self.my_graph.add_plot(hotendtarget_plot) bedactual_plot.points = bedactual_points_list self.my_graph.add_plot(bedactual_plot) bedtarget_plot.points = bedtarget_points_list self.my_graph.add_plot(bedtarget_plot)
def __init__(self, gui_base, **kwargs): # max number of points in a graph self.counter = 0 self.max_points = 100 self.values = [deque(maxlen=self.max_points), deque(maxlen=self.max_points), deque(maxlen=self.max_points)] # By default, there are three graphs available self.graphs = [None, None, None] self.standard_graph_size = (.3, .15) self.standard_graph_size_labelled = (.312, .2105) self.graphs[0] = self.create_basic_graph('X', 0, 600, size_hint=self.standard_graph_size, pos_hint={"top": .98, "left": 1}, x_grid_label=False, xlabel='') self.graphs[1] = self.create_basic_graph('Y', -600, 200, size_hint=self.standard_graph_size, pos_hint={"top": .845, "left": 1}, x_grid_label=False, xlabel='') self.graphs[2] = self.create_basic_graph('Z', 1500, 2500, size_hint=self.standard_graph_size_labelled, pos_hint={"top": .71, "left": 1}) # Each graph has one plot self.plots = [None, None, None] self.plots[0] = SmoothLinePlot(color=[1, 0, 0, 1]) self.plots[1] = SmoothLinePlot(color=[0, 1, 0, 1]) self.plots[2] = SmoothLinePlot(color=[0.6, 1, 1, 1]) # Link plots to graphs self.graphs[0].add_plot(self.plots[0]) self.graphs[1].add_plot(self.plots[1]) self.graphs[2].add_plot(self.plots[2]) # Add the graphs to the root gui_base.root.add_widget(self.graphs[0]) gui_base.root.add_widget(self.graphs[1]) gui_base.root.add_widget(self.graphs[2]) self.root = gui_base.root self.hide_graphs() self.ready = True
def desenha_circulos(self, centro1, raio1, centro2, raio2, centro3, raio3): # circulo1 self.plot_circulo1 = SmoothLinePlot(color=[1, 0, 0, 1]) self.plot_circulo1.points = [ (centro1 + raio1 * math.cos(theta * .01), raio1 * math.sin(theta * .01)) for theta in range(0, 1300) ] # 130 => 40*pi (para dar 2 voltas completas) self.propriedade_grafico.add_plot(self.plot_circulo1) # circulo2 self.plot_circulo2 = SmoothLinePlot(color=[0, 1, 0, 1]) self.plot_circulo2.points = [ (centro2 + raio2 * math.cos(theta * .01), raio2 * math.sin(theta * .01)) for theta in range(0, 1300) ] # 130 => 40*pi (para dar 2 voltas completas) self.propriedade_grafico.add_plot(self.plot_circulo2) # circulo2 self.plot_circulo3 = SmoothLinePlot(color=[0, 0, 1, 1]) self.plot_circulo3.points = [ (centro3 + raio3 * math.cos(theta * .01), raio3 * math.sin(theta * .01)) for theta in range(0, 1300) ] # 130 => 40*pi (para dar 2 voltas completas) self.propriedade_grafico.add_plot(self.plot_circulo3)
def delay(self,dt): self.plot_rpm = SmoothLinePlot(color=[1, 0, 0, 1]) self.plot_tps = SmoothLinePlot(color=[0, 1, 0, 1]) self.plot_iat = SmoothLinePlot(color=[0, 0, 1, 1]) self.plot_map = SmoothLinePlot(color=[1, 1, 0, 1]) self.plot_bat = SmoothLinePlot(color=[1, 0, 1, 1]) self.plot_inj = SmoothLinePlot(color=[0, 1, 1, 1]) self.plot_adv = SmoothLinePlot(color=[1, 1, 1, 1]) self.AllPlot ={ "rpm":self.plot_rpm, "tps":self.plot_tps, "iat":self.plot_iat, "map":self.plot_map, "bat":self.plot_bat, "inj":self.plot_inj, "adv":self.plot_adv }
def graphpoints(self, *args): global g_hotend_actual global g_hotend_target global g_bed_actual global g_bed_target hotendactual_plot = SmoothLinePlot(color=[1, 0, 0, 1]) hotendtarget_plot = MeshLinePlot(color=[1, 0, 0, .75]) bedactual_plot = SmoothLinePlot(color=[0, 0, 1, 1]) bedtarget_plot = MeshLinePlot(color=[0, 0, 1, .75]) # Update temperature graph arrays with new data hotendactual_list.popleft() hotendactual_list.append(g_hotend_actual) hotendtarget_list.popleft() hotendtarget_list.append(g_hotend_target) bedactual_list.popleft() bedactual_list.append(g_bed_actual) bedtarget_list.popleft() bedtarget_list.append(g_bed_target) # Build list of plot points tuples from temp and time lists hotendactual_points_list = [] hotendtarget_points_list = [] bedactual_points_list = [] bedtarget_points_list = [] for i in range(temperature_list_size): hotendactual_points_list.append( (graphtime_list[i] / 1000.0 * -1, int(hotendactual_list[i]))) hotendtarget_points_list.append( (graphtime_list[i] / 1000.0 * -1, int(hotendtarget_list[i]))) bedactual_points_list.append( (graphtime_list[i] / 1000.0 * -1, int(bedactual_list[i]))) bedtarget_points_list.append( (graphtime_list[i] / 1000.0 * -1, int(bedtarget_list[i]))) # Remove all old plots from the graph before drawing new ones while (len(self.my_graph.plots) != 0): # TODO - add a counter so we can abort after a certain number of tries. self.my_graph.remove_plot(self.my_graph.plots[0]) # Draw the new graphs hotendactual_plot.points = hotendactual_points_list self.my_graph.add_plot(hotendactual_plot) hotendtarget_plot.points = hotendtarget_points_list self.my_graph.add_plot(hotendtarget_plot) bedactual_plot.points = bedactual_points_list self.my_graph.add_plot(bedactual_plot) bedtarget_plot.points = bedtarget_points_list self.my_graph.add_plot(bedtarget_plot)
def __init__(self, **kwargs): self.grid = True or kwargs['grid'] self.color = kwargs['color'] self.name = kwargs['name'].upper() self.label = kwargs['name'] self.parent = kwargs['parent'] self.gtype = kwargs['gtype'] self.graph = Graph(ylabel=self.label, x_ticks_minor=1, x_ticks_major=5, y_ticks_major=20, x_grid_label=True, y_grid_label=True, padding=5, x_grid=self.grid, y_grid=self.grid, xmin=0, xmax=50, ymin=0, ymax=20) self.plot = SmoothLinePlot(color=self.color) self.plot.points = [] self.graph.add_plot(self.plot)
def get_daily_mistakes(self): if self.flag == 4: return self.flag = 4 day_list = days_to_ints(get_all_days()) my_day_list = {} for (m, d) in day_list: if m in my_day_list: my_day_list[m].append(d) else: my_day_list[m] = [] my_day_list[m].append(d) new_day_list = [] for eachMonth in my_day_list: for eachDay in my_day_list[eachMonth]: new_day_list.append(eachDay + (eachMonth - 1) * 30) day_om_cost = get_daily_mistake_tuple()[0] day_cm_cost = get_daily_mistake_tuple()[1] points_om_list = self.make_pairs(new_day_list, day_om_cost) points_cm_list = self.make_pairs(new_day_list, day_cm_cost) plot_om = SmoothLinePlot( color=[255 / 255.0, 125 / 255.0, 125 / 255.0, 1]) plot_om.points = points_om_list plot_cm = SmoothLinePlot( color=[125 / 255.0, 177 / 255.0, 255 / 255.0, 1]) plot_cm.points = points_cm_list print("om:" + str(points_om_list)) #Blue print("cm:" + str(points_cm_list)) # Red self.graph7.add_plot(plot_om) self.graph7.add_plot(plot_cm) self.ids['graph3'].remove_widget(self.graph5) self.ids['graph3'].remove_widget(self.graph6) self.ids['graph3'].add_widget(self.graph7)
def build(self): layout = BoxLayout(orientation='vertical') graph_theme = { 'label_options': { 'color': rgb('444444'), # color of tick labels and titles 'bold': True }, 'background_color': rgb('f8f8f2'), # back ground color of canvas 'tick_color': rgb('808080'), # ticks and grid 'border_color': rgb('808080') } # border drawn around each graph x_values = list(range(100)) y_values = [123.0 + random() for x in x_values] end_date = date(2017, 2, 1) one_day = timedelta(1) date_values = [end_date - one_day * i for i in x_values] date_values.reverse() time_series = zip(x_values, y_values) graph1 = TimeSeriesGraph( date_values, date_label_format='%b', xlabel='example 1', ylabel='some y labels', #x_ticks_minor=5, x_ticks_major='month', y_ticks_major=0.1, y_grid_label=True, x_grid_label=True, padding=5, xlog=False, ylog=False, x_grid=True, y_grid=True, #xmin=-50, #xmax=50, ymin=123, ymax=124, font_size='12sp', **graph_theme) plot1 = SmoothLinePlot(color=rgb('7dac9f')) plot1.points = time_series graph1.add_plot(plot1) plot3 = SmoothLinePlot(color=rgb('dc7062')) y_values = [123.0 + random() for x in x_values] time_series = zip(x_values, y_values) plot3.points = time_series graph1.add_plot(plot3) layout.add_widget(graph1) y_values = [123.0 + random() for x in x_values] graph2 = TimeSeriesGraph( date_values, date_label_format='%b-%d', xlabel='example 2', ylabel='some y labels', x_ticks_minor=5, x_ticks_major=30, y_ticks_major=0.1, y_grid_label=True, x_grid_label=True, padding=5, xlog=False, ylog=False, x_grid=True, y_grid=True, #xmin=-50, #xmax=50, ymin=123, ymax=124, font_size='12sp', **graph_theme) plot2 = SmoothLinePlot(color=rgb('7dac9f')) plot2.points = zip(x_values, y_values) graph2.add_plot(plot2) layout.add_widget(graph2) s = Screen(name="test1") s.add_widget(layout) sm = ScreenManager() sm.add_widget(s) return sm
def build(self): self.lplot = SmoothLinePlot(color=COLOR_RED) self.graph.add_plot(self.lplot) self.rplot = SmoothLinePlot(color=COLOR_BLUE) self.graph.add_plot(self.rplot)
def __init__(self, **kwargs): super(RobRehabGUI, self).__init__(**kwargs) self.configStorage = JsonStore('config.json') if self.configStorage.exists('server'): self.ids['address_input'].text = self.configStorage.get( 'server')['address'] if self.configStorage.exists('user'): self.ids['user_name_input'].text = self.configStorage.get( 'user')['name'] self.robotSelector = self.ids['robot_selector'] self.robotEntries = DropDown() self.robotEntries.bind( on_select=lambda instance, name: self.SetRobot(name)) self.robotSelector.bind(on_release=self.robotEntries.open) self.axisSelector = self.ids['axis_selector'] self.axisEntries = DropDown() self.axisEntries.bind( on_select=lambda instance, name: self.SetAxis(name)) self.axisSelector.bind(on_release=self.axisEntries.open) self.enableToggle = self.ids['enable_button'] self.offsetToggle = self.ids['offset_button'] self.calibrationToggle = self.ids['calibration_button'] self.operationToggle = self.ids['operation_button'] self.measureSlider = self.ids['measure_slider'] self.setpointSlider = self.ids['setpoint_slider'] self.forceSlider = self.ids['force_slider'] self.inertiaSlider = self.ids['inertia_slider'] self.stiffnessSlider = self.ids['stiffness_slider'] self.dampingSlider = self.ids['damping_slider'] self.motionSelector = self.ids['motion_selector'] self.motionEntries = DropDown() self.motionEntries.bind( on_select=lambda instance, name: self.SetMotion(name)) self.motionSelector.bind(on_release=self.motionEntries.open) setpointMotions = [] for fileName in os.listdir(self.MOTIONS_DIR): if fileName.endswith('.txt'): setpointMotions.append(os.path.splitext(fileName)[0]) self._UpdateSelectorEntries(self.motionSelector, self.motionEntries, setpointMotions) self.SetMotion(self.DEFAULT_MOTION) self.setpointUpdateEvent = None dataGraph = self.ids['data_graph'] measure_range = self.measureSlider.range GRAPH_PROPERTIES = { 'x_ticks_minor': 5, 'x_ticks_major': 25, 'y_ticks_minor': 0.25, 'y_ticks_major': 0.5, 'y_grid_label': True, 'x_grid_label': True, 'padding': 5, 'x_grid': True, 'y_grid': True, 'xmin': 0, 'xmax': len(self.INITIAL_VALUES) - 1, 'background_color': [1, 1, 1, 1], 'tick_color': [0, 0, 0, 1], 'border_color': [0, 0, 0, 1], 'label_options': { 'color': [0, 0, 0, 1], 'bold': True } } axisPositionGraph = Graph(ylabel='Position/Setpoint', ymin=measure_range[0], ymax=measure_range[1], **GRAPH_PROPERTIES) positionPlot = SmoothLinePlot(color=[0, 0, 1, 1]) axisPositionGraph.add_plot(positionPlot) self.dataPlots.append( RobRehabGUI.DataPlot(positionPlot, self.INITIAL_VALUES[:], self.measures, DOF_POSITION)) velocityPlot = SmoothLinePlot(color=[0, 1, 0, 1]) axisPositionGraph.add_plot(velocityPlot) self.dataPlots.append( RobRehabGUI.DataPlot(velocityPlot, self.INITIAL_VALUES[:], self.measures, DOF_VELOCITY)) accelerationPlot = SmoothLinePlot(color=[1, 1, 0, 1]) axisPositionGraph.add_plot(accelerationPlot) self.dataPlots.append( RobRehabGUI.DataPlot(accelerationPlot, self.INITIAL_VALUES[:], self.measures, DOF_ACCELERATION)) refPositionPlot = SmoothLinePlot(color=[0, 0, 0.5, 1]) axisPositionGraph.add_plot(refPositionPlot) self.dataPlots.append( RobRehabGUI.DataPlot(refPositionPlot, self.INITIAL_VALUES[:], self.setpoints, DOF_POSITION)) dataGraph.add_widget(axisPositionGraph) dataGraph.add_widget(Label(size_hint_y=0.05)) force_range = self.forceSlider.range axisForceGraph = Graph(ylabel='Force/Impedance', ymin=force_range[0], ymax=force_range[1], **GRAPH_PROPERTIES) forcePlot = SmoothLinePlot(color=[1, 0, 0, 1]) axisForceGraph.add_plot(forcePlot) self.dataPlots.append( RobRehabGUI.DataPlot(forcePlot, self.INITIAL_VALUES[:], self.measures, DOF_FORCE)) dampingPlot = SmoothLinePlot(color=[0, 0, 1, 1]) axisForceGraph.add_plot(dampingPlot) self.dataPlots.append( RobRehabGUI.DataPlot(dampingPlot, self.INITIAL_VALUES[:], self.measures, DOF_DAMPING)) inertiaPlot = SmoothLinePlot(color=[0, 1, 0, 1]) axisForceGraph.add_plot(inertiaPlot) self.dataPlots.append( RobRehabGUI.DataPlot(inertiaPlot, self.INITIAL_VALUES[:], self.measures, DOF_INERTIA)) stiffnessPlot = SmoothLinePlot(color=[1, 1, 0, 1]) axisForceGraph.add_plot(stiffnessPlot) self.dataPlots.append( RobRehabGUI.DataPlot(stiffnessPlot, self.INITIAL_VALUES[:], self.measures, DOF_STIFFNESS)) refForcePlot = SmoothLinePlot(color=[0.5, 0, 0, 1]) axisForceGraph.add_plot(refForcePlot) self.dataPlots.append( RobRehabGUI.DataPlot(refForcePlot, self.INITIAL_VALUES[:], self.setpoints, DOF_FORCE)) dataGraph.add_widget(axisForceGraph) dataGraph.add_widget(Label(text='Last Samples', size_hint_y=0.1)) Clock.schedule_interval(self.DataUpdate, self.UPDATE_INTERVAL / 2) Clock.schedule_interval(self.GraphUpdate, self.UPDATE_INTERVAL * 2) Clock.schedule_interval(self.SliderUpdate, self.UPDATE_INTERVAL)
def desenha_linha(self, xstress, ystress, xyshear): self.plot_linha_inicial = SmoothLinePlot(color=[0, 1, 0, 1]) self.plot_linha_inicial.points = [(xstress, xyshear), (ystress, -xyshear)] self.propriedade_grafico.add_plot(self.plot_linha_inicial)
def graph(self): soln_graph = screen_manager.get_screen('solution').layout fx = Fx(shunt(self.eq)).eval colors = itertools.cycle([ rgb('dc7062'), rgb('fff400'), rgb('7dac9f'), rgb('66a8d4'), rgb('e5b060') ]) fxplot = SmoothLinePlot(color=next(colors)) for i in range(-500, 501): x = i / 10. y = fx(x) fxplot.points.append((x, y)) soln_graph.graph.add_plot(fxplot) if self.solutions: plot = MeshLinePlot(color=rgb('fff400')) xmin = float(round(self.solutions[0], 4)) xmax = float(xmin) ymin = fx(xmin) ymax = ymin xmin = xmin xmax = xmin Logger.info("Plotting") plotx = MeshLinePlot(color=next(colors)) plotx.points = [(float(x), fx(x)) for x in self.solutions] counter = len(self.solutions) while counter >= 3: Logger.info(counter) for index in range(min(3, counter)): x = round(float(self.solutions[index]), 4) y = round(float(fx(x)), 4) x = x xmin = float(min([xmin, x])) xmax = float(max([xmax, x])) ymin = float(min([ymin, y])) ymax = float(max([ymax, y])) plot.points.append((x, y)) counter = counter - 1 if len(plot.points) >= min(3, len(self.solutions)): Logger.debug(['pts', plot.points]) soln_graph.graph.add_plot(plot) plot = MeshLinePlot(color=next(colors)) self.solutions.pop(0) counter = len(self.solutions) break pad = 0.1 Logger.debug(plot.points) soln_graph.graph.xmin = round(xmin - pad, 1) soln_graph.graph.xmax = round(xmax + pad, 1) soln_graph.graph.ymin = round(ymin - pad, 2) soln_graph.graph.ymax = round(ymax + pad, 2) hbar = MeshLinePlot(color=[1, 1, 1, 1]) hbar.points.append((soln_graph.graph.xmin, 0)) hbar.points.append((soln_graph.graph.xmax, 0)) soln_graph.graph.add_plot(hbar) for x, y in plotx.points: vbar = MeshLinePlot(color=rgb('6d98e2')) vbar.points.append((x, 0)) vbar.points.append((x, y)) soln_graph.graph.add_plot(vbar)