def __init__(self, **kwargs): super(case, self).__init__(**kwargs) box = FloatLayout() 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=20, ymin=0, ymax=10) plot = LinePlot() # plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] # data = np.array([[0,0], [1,1],[2,2]]) data = collections.deque(maxlen = 20) time = collections.deque(maxlen = 20) d = (0,1,2,3,4,5,6,7,8,9) t = (0,1,2,3,4,5,6,7,8,9) data.append(d) time.append(t) toplot = np.vstack((time,data)).T print toplot plot.points = tuple(map(tuple, toplot)) graph.add_plot(plot) box.add_widget(graph) self.add_widget(box)
def init(self): # use kivy garden's graph widget graph = Graph( xlabel='t', ylabel='HFR', x_ticks_minor=5, x_ticks_major=10, y_ticks_minor=1, y_ticks_major=5, y_grid_label=True, x_grid_label=False, padding=0, y_grid=False, x_grid=False, xmin=0, ymin=0, xmax=100, ymax=30, _with_stencilbuffer=False, # or it does not work in ScreenManager label_options={'color': rgb('808080')}) y = (float(i) for i in range(50)) x = (float(i) for i in range(50)) plot = MeshLinePlot(color=rgb('1100aa')) pts = list(zip(x, y)) plot.points = pts graph.add_plot(plot) self.ids.plot.add_widget(graph) self.plot = plot self.graph = graph
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)
class Plot(RelativeLayout): def __init__(self, **kwargs): super(Plot, self).__init__(**kwargs) self.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, x_grid=True, y_grid=True, xmin=-0, xmax=100, ymin=-1, ymax=1, draw_border=False) # graph.size = (1200, 400) # self.graph.pos = self.center self.plot = MeshLinePlot(color=[1, 1, 1, 1]) self.plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] self.plot2 = MeshLinePlot(color=[1, 0, 0, 1]) self.plot2.points = [(x, cos(x / 10.)) for x in range(0, 101)] self.add_widget(self.graph) self.graph.add_plot(self.plot) self.graph.add_plot(self.plot2)
def graph_create(self): global graph1 graph1 = Graph( label_options={'color': rgb('001933'), 'bold': True}, background_color=rgb('f8f8f2'), tick_color=rgb('001933'), border_color=rgb('808080'), xlabel='X', ylabel='Y', y_grid_label=True, x_grid_label=True, padding=5, x_ticks_major=5, y_ticks_major=0.2, x_grid=True, y_grid=True, xmin=-0, xmax=30, ymin=-1, ymax=1) k = np.random.normal() global plot1 plot1 = MeshLinePlot(color=[0, 0, 0.75, 1]) y = (0.5 - 0.2)/30*np.linspace(0, max_year-1, max_year) + 0.2*np.ones(max_year) + np.random.normal(0, 0.05, max_year) plot1.points = [(x, y[x]) for x in range(0, 30)] graph1.add_plot(plot1) self.add_widget(graph1) return graph1
def init(self, octoprint): self.octoprint = octoprint # use kivy garden's graph widget graph = Graph( xlabel='', ylabel='°C', x_ticks_minor=5, x_ticks_major=25, y_ticks_minor=0, y_ticks_major=50, y_grid_label=True, x_grid_label=False, padding=5, y_grid=True, xmax=len(self.hotend_temps), ymax=230, _with_stencilbuffer=False, # or it does not work in ScreenManager label_options={'color': rgb('000000')}) self.hotend_plot = MeshLinePlot(color=[1, 0, 0, 1]) self.bed_plot = MeshLinePlot(color=[0, 0, 1, 1]) graph.add_plot(self.hotend_plot) graph.add_plot(self.bed_plot) self.ids.plot.add_widget(graph) self.graph = graph self.update_plot() self.status = "Ready."
def f_u_wid(self): graph = Graph(xlabel='displacement', ylabel='force', x_ticks_minor=5, x_ticks_major=1, y_ticks_major=100, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0, xmax=self.max_displacement, ymin=-100, ymax=500) self.f_u_line = MeshLinePlot(color=[1, 1, 1, 1]) self.f_u_line.points = [(0, 0)] graph.add_plot(self.f_u_line) return graph
def eps_sig_wid(self): graph = Graph(xlabel='slip', ylabel='bond', x_ticks_minor=5, x_ticks_major=0.5, y_ticks_major=0.2, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=-0.0 * self.max_displacement, xmax=0.8 * self.max_displacement, ymin=-1, ymax=1) self.eps_sig_line = MeshLinePlot(color=[1, 1, 1, 1]) self.eps_sig_line.points = [(0, 0)] graph.add_plot(self.eps_sig_line) return graph
def cb_wid(self): graph = Graph(xlabel='z', ylabel='matrix stress', x_ticks_minor=5, x_ticks_major=25, y_ticks_major=5, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=-50, xmax=50, ymin=0, ymax=20) self.cb_line = MeshLinePlot(color=[1, 0, 0, 1]) self.sctt.get_sig_m_cb() self.cb_line.points = self.list_tuple(self.sctt.z, self.sctt.sig_m_cb) graph.add_plot(self.cb_line) return graph
def shear_flow_wid(self): graph = Graph(xlabel='length', ylabel='shear flow', background_color=[0, 0, 0, 1], x_ticks_major=100., y_ticks_major=0.2, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0.0, xmax=self.tl.ts.L_x, ymin=-1, ymax=1) self.shear_flow_line = MeshLinePlot(color=[1, 1, 1, 1]) self.shear_flow_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) graph.add_plot(self.shear_flow_line) return graph
class GaugeGraph: """ Graph data presentation """ 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 update(self): """ Method to update the graph :return: """ try: values = list(map(int, self.parent.pids[self.name]['values'])) if len(values) > 1: y_max = max(values) y_min = min(values) self.graph.ymin = y_min self.graph.ymax = y_max if y_max > 10: self.graph.y_ticks_minor = int(y_max / 10) self.graph.y_ticks_major = int(y_max / 5) else: self.graph.y_ticks_minor = 1 self.graph.y_ticks_major = 5 self.plot.points = [] i = 0 while i < len(values): self.plot.points.append([i, values[i]]) i += 1 self.graph.add_plot(self.plot) except Exception as exceptn: print("Exception in graph update occured: " + str(exceptn))
def curve_wid(self): graph = Graph(xlabel='strain', ylabel='stress', x_ticks_major=0.001, y_ticks_major=2, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0, xmax=0.01, ymin=0, ymax=self.sctt.sig_cu) self.eps_sig_line = MeshLinePlot(color=[1, 1, 1, 1]) self.eps_sig_line.points = self.list_tuple( self.sctt.eps_c_K, self.sctt.sig_c_K) graph.add_plot(self.eps_sig_line) return graph
def build(self): self.title = "HP4156C Parameter Analyser" ## Main screen has a title and two accordions root = BoxLayout(orientation='vertical') ## Add a title header to the window 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=100, ymin=-1, ymax=1) plot = MeshLinePlot(color=[1, 0, 0, 1]) plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] graph.add_plot(plot) root.add_widget(graph) return root
def build(self): print 'create graph' #self.canvas.add(Color(1., 1., 0)) 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=100, ymin=-1, ymax=1) plot = MeshLinePlot(color=[1, 0, 0, 1]) plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] graph.add_plot(plot) return graph
def cracking_wid(self): graph = Graph(xlabel='x', ylabel='matrix stress', x_ticks_minor=5, x_ticks_major=100, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0, xmax=1000, ymin=0, ymax=5) self.sig_mu_line = MeshLinePlot(color=[1, 0, 0, 1]) self.sig_mu_line.points = self.list_tuple( self.sctt.x, self.sctt.sig_mu_x) self.sig_line = MeshLinePlot(color=[1, 1, 1, 1]) graph.add_plot(self.sig_mu_line) graph.add_plot(self.sig_line) return graph
class Main(App): def build(self): root = BoxLayout() self.graph = Graph( y_grid_label=False, x_grid_label=False, padding=5, xmin=0, xmax=100, ymin=0, ymax=30) line = MeshLinePlot(points=[(0, 0), (100, 30)]) self.graph.add_plot(line) root.add_widget(self.graph) return root
class EAGraph(BoxLayout): def __init__(self): super(EAGraph, self).__init__() self.graph = Graph( xlabel="Generation", ylabel="Y", x_ticks_minor=5, x_ticks_major=25, y_ticks_minor=5, y_ticks_major=40, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0, xmax=120, ymin=0, ymax=200, size=(800, 600) ) red = [1, 0, 0, 1] green = [0, 1, 0, 1] blue = [0, 0, 1, 1] self.cols = 2 self.orientation = 'vertical' self.add_widget(self.graph) legends = BoxLayout() legends.orientation = 'horizontal' legends.add_widget(Label(text='Standard deviation', color=red, size=(100, 200))) legends.add_widget(Label(text='Average fitness', color=green, size=(100, 200))) legends.add_widget(Label(text='Highest fitness', color=blue, size=(100, 200))) self.add_widget(legends) self.plot = [] self.plot.append(MeshLinePlot(color=red)) #X - Red self.plot.append(MeshLinePlot(color=green)) #Y - Green self.plot.append(MeshLinePlot(color=blue)) #Z - Blue for plot in self.plot: self.graph.add_plot(plot) def add_datas(self, datas, generation): for i in range(len(datas)): self.plot[i].points.append((generation, datas[i]))
class SuccessGraph(object): PLOT_LINE_COLOR = [1, 0, 0, 1] DEFAULT_LEVEL = "Overall" X_LABEL = "sessions" Y_LABEL = "success rates" Y_MAX_VAL = 100 HISTORY_MAX = 200 X_MAJOR_TICKS_SCALE = 8.0 def __init__(self): self._plot = MeshLinePlot(color=self.PLOT_LINE_COLOR) self._graph = Graph(xlabel=self.X_LABEL, ylabel=self.Y_LABEL, x_ticks_minor=5, y_ticks_major=10, y_ticks_minor=2, y_grid=True, y_grid_label=True, x_grid_label=True, padding=10, xmin=0, ymin=0, ymax=self.Y_MAX_VAL, xmax=self.HISTORY_MAX) self.level = None self.stats = App.get_running_app().stats self.display_level(self.DEFAULT_LEVEL) self._graph.add_plot(self._plot) def display_level(self, level): if self.DEFAULT_LEVEL == level: self.level = None else: self.level = int(level) success_rates = self.stats.success_rates(self.level) # limit items to last HISTROY_MAX items success_rates = success_rates[-self.HISTORY_MAX:] self._plot.points = [(x, y) for x, y in enumerate(success_rates)] points_count = len(success_rates) self._graph.xmax = points_count self._graph.x_ticks_major = round_up(points_count / self.X_MAJOR_TICKS_SCALE) def get_view(self): return self._graph def clear_statistics(self, *largs): """Delete actually selected statistics""" self.stats.delete_rows(self.level) self.display_level(self.DEFAULT_LEVEL)
def build(self): self.availablePorts = listSerialPorts() if len(self.availablePorts) == 0: self.availablePorts.append("----") tabbedPannel = TabbedPanel(do_default_tab=False) # Connection Tab self.connectionTab = TabbedPanelItem(text="Connection") self.layout1 = BoxLayout(orientation='vertical', spacing=10, padding=(200, 200)) self.connectionTab.add_widget(self.layout1) self.lblSerialSettings = Label(text="Connection settings") self.layout1.add_widget(self.lblSerialSettings) self.dlBaudrate = Spinner(values = ["57600", "115200", "230400", "460800", "921600"], text = "115200") self.layout1.add_widget(self.dlBaudrate) self.dlPort = Spinner(values = self.availablePorts, text = self.availablePorts[0]) self.layout1.add_widget(self.dlPort) self.btnConnect = Switch() self.btnConnect.bind(active = self.connect) self.layout1.add_widget(self.btnConnect) # Graph tab self.graphTab = TabbedPanelItem(text = "Graph") # self.layout2 = BoxLayout(orientation='vertical', spacing=10, padding=(200, 200)) # self.graphTab.add_widget(self.layout2) 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=100, ymin=-1, ymax=1) plot = MeshLinePlot(color=[1, 1, 0, 1]) plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] graph.add_plot(plot) self.graphTab.add_widget(graph) tabbedPannel.add_widget(self.connectionTab) tabbedPannel.add_widget(self.graphTab) return tabbedPannel
def build(self): root = FloatLayout(orientation='horizontal') btnRight = Button(text='Scroll', size_hint=(.05,1),pos_hint={'right':1})#,'y':0}) btnLeft = Button(text='Scroll', size_hint=(.05,1),pos_hint={'left':1}) root.add_widget(btnRight) root.add_widget(btnLeft) # scrollV = ScrollView(size_hint=(None,None),size=(800,400)) # scrollV.do_scroll_y=False graph = Graph() plot = LinePlot(mode='line_strip', color=[1,0,0,1]) plot.points = [(x[i],y[i]) for i in xrange(len(x))] graph.add_plot(plot) graph.x_ticks_major=1 graph.xmin=xmin graph.xmax=xmax graph.ymin=ymin graph.ymax=ymax graph.y_ticks_major=25 graph.y_grid_label=True graph.x_grid_label=True graph.xlabel='X axis' graph.ylabel='Y axis' graph.y_grid = True graph.x_grid = True def moveRight(obj): global xmin global xmax xmin=xmin+.5 xmax=xmax+.5 graph.xmin=xmin graph.xmax=xmax #graph.remove_plot(plot) #graph.add_plot(plot) #graph._redraw_size(xmin,ymin,xmax,ymax) btnRight.bind(on_release=moveRight) def moveLeft(obj): global xmin global xmax xmin=xmin-.5 xmax=xmax-.5 graph.xmin=xmin graph.xmax=xmax btnLeft.bind(on_release=moveLeft) root.add_widget(graph) # graph.bind(minimum_height=graph.setter('height')) # scrollV.add_widget(graph) return root
def build(self): print 'create graph' 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 = MeshLinePlot(color=[1, 0, 0, 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) return graph
def mostrar_histograma(self): """ Mostra o histograma da imagem. """ histograma = self.imagem_core.get_histograma() graph = Graph(xlabel='Tom de Cinza', ylabel='Quantidade de tons', padding=5, xmin=0, xmax=max(histograma.keys()), ymin=0, ymax=max(histograma.values())) plot = MeshLinePlot() plot.points = histograma.items() graph.add_plot(plot) self.widgets_dinamicos.append(graph) self.add_widget(graph)
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 __init__(self, **kwargs): super(case, self).__init__(**kwargs) box = FloatLayout() 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=20, ymin=0, ymax=10) plot = LinePlot() # plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] # data = np.array([[0,0], [1,1],[2,2]]) data = collections.deque(maxlen=20) time = collections.deque(maxlen=20) d = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) data.append(d) time.append(t) toplot = np.vstack((time, data)).T print toplot plot.points = tuple(map(tuple, toplot)) graph.add_plot(plot) box.add_widget(graph) self.add_widget(box)
class GraphApp(App): def build(self): super().__init__() self.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=100, ymin=-1, ymax=1) self.plot = MeshLinePlot(color=[1, 0, 0, 1]) self.plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] self.graph.add_plot(self.plot) return self.graph
def build(self): b = BoxLayout(orientation='vertical') graph2 = Graph( xlabel='x', ylabel='y', x_ticks_major=10, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=5, xlog=False, ylog=False, xmin=0, ymin=0) plot = LinePlot(color=[255, 255, 255], width=100.) plot.points = [(10, 10), (90, 90)] graph2.add_plot(plot) b.add_widget(graph2) return b
def build(self): b = BoxLayout(orientation='vertical') graph2 = Graph( xlabel='x', ylabel='y', x_ticks_major=10, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=0, xlog=False, ylog=False, xmin=0, ymin=0) plot = FilledRect(color=[255, 255, 255]) plot.xrange = [40, 70] plot.yrange = [30, 50] graph2.add_plot(plot) # plot2 = FilledRect(color=[255, 255, 255]) # plot2.xrange = [50, 70] # plot2.yrange = [30, 50] label = Label(text='test', font_size=20) label.pos = (100, 100) # text = label.texture # plot2.texture = text graph2.add_widget(label) b.add_widget(graph2) self.rectangle = plot # Clock.schedule_interval(self.update_color, 1) # Clock.schedule_interval(self.update_pos, 1) return b
def __init__(self, **kwargs): super(RootWidget, 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=100, ymin=-1, ymax=1) graph.background_color = 0, 0, 1, 1 # blue color plot = MeshLinePlot(color=[1, 0, 0, 1]) plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] graph.add_plot(plot) self.add_widget(graph)
def disp_slip_wid(self): graph = Graph(xlabel='length', ylabel='displacement', background_color=[0, 0, 0, 1], x_ticks_major=100., y_ticks_major=1.0, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0.0, xmax=self.tl.ts.L_x, ymin=0., ymax=self.max_displacement) self.reinf_disp_line = MeshLinePlot(color=[1, 1, 1, 1]) self.reinf_disp_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) self.matrix_disp_line = MeshLinePlot(color=[1, 1, 1, 1]) self.matrix_disp_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) self.slip_line = MeshLinePlot(color=[1, 1, 1, 1]) self.slip_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) graph.add_plot(self.reinf_disp_line) graph.add_plot(self.matrix_disp_line) graph.add_plot(self.slip_line) return graph
class DrawScreen(Screen): def __init__(self, **kwargs): super(DrawScreen, self).__init__(**kwargs) self.graph_layout = BoxLayout(orientation = 'vertical',pos_hint = {'center_y': .55, 'center_x': .25 }, size_hint= (.45, .85), spacing = 10) self.draw_layout = BoxLayout(orientation = 'vertical',pos_hint = {'center_y': .55, 'center_x': .75}, size_hint= (.45, .85), color = [.5,.5,.5,1], spacing = 10) self.button_layout = BoxLayout(orientation = 'horizontal',pos_hint = {'center_y': .0001, 'center_x': .5}, size_hint= (.9, .1), color = [.5,.5,.5,1], spacing = 100) self.add_widget(self.graph_layout) self.add_widget(self.draw_layout) self.add_widget(self.button_layout) self.plots = [] self.anim_counter = 0 self.graph = Graph(draw_border = False, background_color = [1, 1, 1, 1], border_color = [.3, .5, .6, .7]) self.graph.pos_hint={'center_y': .5} self.graph.size_hint_y = .9 clear_graph_btn_image = os.path.join(app.resource_folder, 'eraser.png') self.clear_graph = Button(background_normal = clear_graph_btn_image, border = [1,1,1,1], size_hint=(.00000001, .5), pos_hint = {'center_y': 1, 'center_x': .4 }) self.clear_graph.opacity = 1 self.clear_graph.disabled = False self.clear_graph.bind(on_press = self.clear_plot) self.gap_btn1 = Button(border = [1,1,1,1], size_hint=(.00000005, .5), pos_hint = {'center_y': 1, 'center_x': .4 }) self.gap_btn1.opacity = 0 self.gap_btn1.disabled = True self.gap_btn2 = Button(border = [1,1,1,1], size_hint=(.00000005, .5), pos_hint = {'center_y': 1, 'center_x': .4 }) self.gap_btn2.opacity = 0 self.gap_btn2.disabled = True next_btn_image = os.path.join(app.resource_folder, 'next.png') self.next_graph = Button(background_normal = next_btn_image, border = [1,1,1,1], size_hint=(.00000001, .7), pos_hint = {'center_y': 1, 'center_x': .5 }) self.next_graph.opacity = 1 self.next_graph.disabled = False self.next_graph.bind(on_press = self.next_plot) eraser_btn_image = os.path.join(app.resource_folder, 'eraser.png') self.eraser = Button(background_disabled_normal = eraser_btn_image,background_normal = eraser_btn_image, border = [1,1,1,1], size_hint=(.00000001, .5), pos_hint = {'center_y': 1, 'center_x': .8 }) self.eraser.opacity = 1 self.eraser.disabled = True # self.animate_btn = Button(background_normal = 'next.png', border = [1,1,1,1], # size_hint=(.00000001, .4), # pos_hint = {'center_y': 1, 'center_x': .5 }) # self.animate_btn.opacity = 1 # self.animate_btn.disabled = False # self.animate_btn.bind(on_press=self.start_animation) self.painterbox = PainterBox(btn = self.eraser) self.eraser.bind(on_press=self.painterbox.clear_letter) child_btn_image = os.path.join(app.resource_folder, 'child.png') self.child_btn = Button(background_disabled_normal = child_btn_image, background_normal = child_btn_image, border = [1,1,1,1], size_hint=(.1, .1), pos_hint = {'center_y': .9, 'center_x': .5 }) self.child_btn.opacity = 1 self.child_btn.disabled = False self.child_btn.bind(on_press=self.start_animation) nao_btn_image = os.path.join(app.resource_folder, 'nao.png') self.nao_btn = Button(background_disabled_normal = nao_btn_image, background_normal = nao_btn_image, border = [1,1,1,1], size_hint=(.1, .1), pos_hint = {'center_y': .9, 'center_x': .5 }) self.nao_btn.opacity = 1 self.nao_btn.disabled = False self.nao_btn.bind(on_press=self.on_nao_turn) self.graph_layout.add_widget(self.nao_btn) self.graph_layout.add_widget(self.graph) self.button_layout.add_widget(self.clear_graph) # self.button_layout.add_widget(self.animate_btn) self.button_layout.add_widget(self.gap_btn1) self.button_layout.add_widget(self.next_graph) self.button_layout.add_widget(self.gap_btn2) self.button_layout.add_widget(self.eraser) self.draw_layout.add_widget(self.child_btn) self.draw_layout.add_widget(self.painterbox) return def on_nao_turn(self, *args): if self.on_send_char is not None: #call this self.on_send_char() return def create_plot(self, *args): return LinePlot(color=[0, 0.443, 0.737, 1], line_width = 3) # orange def clear_plot(self, *args): # self.graph.remove_plot(self.plot) # self.graph.remove_plot(self.plot1) for plot in self.plots: self.graph.remove_plot(plot) self.plots = [] return def next_plot(self, *args): self.clear_plot() self.painterbox.clear_letter() self.eraser.disabled = True app.counter += 1 if app.counter > 14 or app.counter >= len(self.keys): app.sm.current = 'fs' else: self.curr_char = self.keys[app.counter] self.curr_data = self.data[self.curr_char][0] self.draw(self.curr_data) return def on_enter(self): data_file = os.path.join(app.resource_folder, 'file_p', app.file_p) self.data = cp.load(open(data_file, 'rb')) self.keys = self.data.keys() self.curr_char = self.keys[0] self.curr_data = self.data[self.curr_char][5] self.draw(self.curr_data) return def max_min_range(self, data): d = 0 x_ma = [] y_mi = [] x_mi = [] y_ma = [] for stroke in data: #print stroke x_max = x_ma.append(int(round(max(stroke[ :, 0]) + d))) y_max = y_ma.append(int(round(max(stroke[ :, 1]) + d))) x_min = x_mi.append(int(round(min(stroke[ :, 0]) + d))) y_min = y_mi.append(int(round(min(stroke[ :, 1]) + d))) x_max = max(x_ma) y_max = max(y_ma) x_min = min(x_mi) y_min = min(y_mi) return x_max, y_max, x_min, y_min def set_graph_margin(self, strokes): self.x_max, self.y_max, self.x_min, self.y_min = self.max_min_range(strokes) x_margin = round(np.abs(self.x_max - self.x_min) * 0.2) y_margin = round(np.abs(self.y_max - self.y_min) * 0.2) x_margin = 1 if x_margin < 1 else x_margin y_margin = 1 if y_margin < 1 else y_margin a = max([x_margin, y_margin]) self.graph.xmin = self.x_min -a self.graph.xmax = self.x_max +a self.graph.ymin = self.y_max +a self.graph.ymax = self.y_min -a # print self.x_max, self.y_max, self.x_min, self.y_min return def draw(self, strokes): self.clear_plot() self.set_graph_margin(strokes) # process each stroke for s in strokes: self.plots.append(self.create_plot()) self.plots[-1].points = s self.graph.add_plot(self.plots[-1]) return def update(self, stroke): """ update the last stroke plot with the given stroke, if there's currently no stroke, create one """ if not self.plots: self.plots.append(self.create_plot()) self.plots[-1].points = stroke self.graph.add_plot(self.plots[-1]) else: #update the last stroke self.plots[-1].points = stroke return def start_animation(self, *args): self.animate(strokes=self.curr_data, wait=2.5, freq=10, strk_interval=2.5) return def animate(self, strokes, wait=0.5, freq=20, strk_interval=1.0): """ Animating the stroke trajectories with given settings: wait - how long to wait before start the animating: unit - sec freq - how often to update the plot strk_interval - interval between strokes """ self.set_graph_margin(strokes) self.clear_plot() # process each stroke self.anim_counter = 0 self.anim_counter_strk_len = np.array([len(s) for s in strokes]) self.anim_wait = wait self.anim_freq = freq self.anim_strk_interval = strk_interval self.anim_n_strks = len(strokes) self.anim_strk_idx = 0 self.anim_strokes = strokes def schedule_stroke_handler(dt): Clock.schedule_interval(animate_stroke_handler, 1. / self.anim_freq) return False def animate_stroke_handler(dt): #check if we are at the end of te stroke if self.anim_counter >= self.anim_counter_strk_len[self.anim_strk_idx]: #close the schedule if reached the last point if self.anim_strk_idx >= self.anim_n_strks - 1: return False else: #refresh counter and move to the next stroke self.anim_counter = 0 self.anim_strk_idx += 1 #also remember to add a new plot to this stroke self.plots.append(self.create_plot()) self.graph.add_plot(self.plots[-1]) Clock.schedule_once(schedule_stroke_handler, self.anim_strk_interval) return False #process the plot update stroke_update = self.anim_strokes[self.anim_strk_idx][:(self.anim_counter+1), :] self.update(stroke_update) #increase the counter self.anim_counter += 1 return #start the schedule after specified waitting time Clock.schedule_once(schedule_stroke_handler, self.anim_wait) return
class DatabaseScreen(Screen): def __init__(self, **kwargs): super(Screen, self).__init__(**kwargs) self.allowed_receive_database = True self.error = Image( source='Img/error.png', allow_stretch=False, keep_ratio=True, pos_hint={"center_x": 0.095, "center_y": 0.64}, size_hint=(0.11, 0.11)) self.wait = Image( source='Img/wait.png', allow_stretch=False, keep_ratio=True, pos_hint={"center_x": 0.095, "center_y": 0.64}, size_hint=(0.11, 0.11)) 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 self.graph1 = Graph( xlabel='Time [s]', ylabel='Value', x_ticks_minor=5, x_ticks_major=5, y_ticks_minor=1, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=5, xlog=False, ylog=False, x_grid=False, y_grid=False, xmin=0, xmax=30, ymin=0, ymax=100, pos_hint={'center_x': 0.5, 'center_y': 0.5}, _with_stencilbuffer=False, **graph_theme) self.graph2 = Graph( xlabel='Time [s]', ylabel='Value', x_ticks_minor=5, x_ticks_major=5, y_ticks_minor=1, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, xlog=False, ylog=False, x_grid=False, y_grid=False, xmin=0, xmax=30, ymin=-5, ymax=5, pos_hint={'center_x': 0.5, 'center_y': 0.5}, _with_stencilbuffer=False, **graph_theme) self.plot1 = LinePlot(line_width=2, color=[1, 0, 0, 1]) self.plot1.points = [(i, j*10/3) for i, j in enumerate(range(31))] self.graph1.add_plot(self.plot1) self.ids.panel1.add_widget(self.graph1) self.plot2 = LinePlot(line_width=2, color=[1, 0, 0, 1]) self.plot2.points = [(i, j/3 - 5) for i, j in enumerate(range(31))] self.graph2.add_plot(self.plot2) self.ids.panel2.add_widget(self.graph2) def wait_for_database(self, dt): self.allowed_receive_database = True self.remove_widget(self.error) self.remove_widget(self.wait) def get_database(self): if GlobalShared.wifi is True: if self.allowed_receive_database is True: self.allowed_receive_database = False Clock.schedule_once(self.wait_for_database, 2) check = None try: s.send(str.encode('DB')) answer = s.recv(4096) check = answer[-2:] except IOError: GlobalShared.error = True GlobalShared.wifi = False if check == b'GD': self.data = pickle.loads(answer[:-2]) if self.data != []: try: xmin = min([el[0] for el in self.data]) xmax = max([el[0] for el in self.data]) self.graph1.xmin = xmin self.graph1.xmax = xmax self.graph2.xmin = xmin self.graph2.xmax = xmax x_points = [el[0] for el in self.data] panel1_points = [el[1] for el in self.data] panel2_points = [el[2] for el in self.data] self.plot1.points = [el for el in zip(x_points, panel1_points)] self.plot2.points = [el for el in zip(x_points, panel2_points)] self.remove_widget(self.error) self.remove_widget(self.wait) except: pass else: self.remove_widget(self.error) self.remove_widget(self.wait) self.add_widget(self.error) elif check == b'': GlobalShared.error = True GlobalShared.wifi = False self.remove_widget(self.error) self.remove_widget(self.wait) self.add_widget(self.error) else: self.remove_widget(self.error) self.remove_widget(self.wait) self.add_widget(self.error) else: self.remove_widget(self.error) self.remove_widget(self.wait) self.add_widget(self.wait) else: self.remove_widget(self.error) self.remove_widget(self.wait) self.add_widget(self.error) def delete_all(self): self.remove_widget(self.wait) self.remove_widget(self.error)
def __init__(self, **kwargs): super(MainLayout, self).__init__(**kwargs) def redraw(self, args): self.bg_rect.size = self.size self.bg_rect.pos = self.pos with self.canvas: self.bg_rect = Rectangle(source="steel.jpg", pos=self.pos, size=self.size) self.bind(pos=redraw, size=redraw) root = BoxLayout(orientation='vertical', padding=[15], spacing=15) # Add loading file with data gl = GridLayout(cols=2, size_hint=(1, 0.95), size_hint_min=(100, 100), spacing=10) # Results section resl = BoxLayout(size_hint=(0.6, 0.98), size_hint_min=(100, 100), orientation='vertical', spacing=15) # Graph 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=100, ymin=-1, ymax=1) plot = MeshLinePlot(color=[1, 0, 0, 1]) plot.points = [(x, x) for x in range(0, 101)] graph.add_plot(plot) resl.add_widget(graph) # Options section bl = BoxLayout(size_hint=(0.4, 0.98), size_hint_min=(100, 100), orientation='vertical', spacing=15) bl.add_widget( Label(text='Wybierz plik danych', size_hint=(1, 0.05), size_hint_min=(200, 20))) files = FileChooserListView(size_hint=(1, 0.95), path=os.environ['HOMEDRIVE'] \ + os.environ['HOMEPATH']) bl.add_widget(files) bl.add_widget( Label(text='Wybierz metodę interpolacji', size_hint=(1, 0.05), size_hint_min=(200, 30))) # Choosing interpolation method dd = DropDown() for interpolation in ['liniowa', 'wielomianowa']: btn = Button(text=interpolation, size_hint_y=None, height=30) btn.bind(on_release=lambda btn: dd.select(btn.text)) dd.add_widget(btn) dd_interpol_btn = Button(text='liniowa', size_hint=(1, 0.05), size_hint_min=(80, 30)) dd_interpol_btn.bind(on_release=dd.open) dd.bind( on_select=lambda instance, x: setattr(dd_interpol_btn, 'text', x)) bl.add_widget(dd_interpol_btn) # Add widgets to root layout root.add_widget( Label(text='Entalpy Calculator', size_hint=(1, 0.05), size_hint_min_y=20)) gl.add_widget( Label(text='Wyniki', size_hint=(0.6, 0.02), size_hint_min_y=20)) gl.add_widget( Label(text='Opcje', size_hint=(0.4, 0.02), size_hint_min_y=20)) gl.add_widget(resl) gl.add_widget(bl) root.add_widget(gl) calculate_btn = Button(text='Oblicz', size_hint=(1, 0.05), size_hint_min_y=30) calc_callback = partial(calculate, file_chooser=files, ip_btn=dd_interpol_btn) calculate_btn.bind(on_release=calc_callback) root.add_widget(calculate_btn) self.add_widget(root)
class VisualizationApp(App): def __init__(self, data_file, measure_collections_f, additional_interval, restart=True, **kwargs): super(VisualizationApp, self).__init__(**kwargs) self.restart = restart self.data_file = data_file self.additional_interval = additional_interval self.camera_folder = data_file + '_images_Camera\\' self.camera_files = sorted([ f for f in os.listdir(self.camera_folder) if os.path.isfile(os.path.join(self.camera_folder, f)) and f.endswith('.jpg') ]) self.ground_truth_file = [ os.path.join(self.camera_folder, f) for f in os.listdir(self.camera_folder) if os.path.isfile(os.path.join(self.camera_folder, f)) and f.startswith('00gt') ][0] self.image = Image(source=os.path.join(self.camera_folder, self.camera_files[0]), size=(352, 288), pos=(0, 0)) #with self.image.canvas as canvas: # Color(1., 0, 0) # Rectangle(size=(1, 10000)) self.graph = Graph( xlabel='Time [s]', ylabel='Distance [m]', #x_ticks_minor=0.5, x_ticks_major=2, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=10, x_grid=True, y_grid=True, xmin=0, xmax=0, ymin=-1, ymax=11) last_mc = None self.first_timestamp = measure_collections_f[0].first_measure( ).timestamp for mc in measure_collections_f: color = [1, 1, 0, 1] if mc.prediction == 'FREE_SPACE': color = [1, 0, 1, 1] elif mc.prediction == 'PARKING_CAR': color = [0, 1, 1, 1] elif mc.prediction == 'OVERTAKING_SITUATION': color = [0, 0, 1, 1] plot = MeshLinePlot(color=color) plot.points = [(m.timestamp - self.first_timestamp, m.distance) for m in mc.measures] self.graph.add_plot(plot) color_actual = [1, 1, 0, 1] if mc.get_probable_ground_truth() == GroundTruthClass.FREE_SPACE: color_actual = [1, 0, 1, 1] elif GroundTruthClass.is_parking_car( mc.get_probable_ground_truth()): color_actual = [0, 1, 1, 1] elif GroundTruthClass.is_overtaking_situation( mc.get_probable_ground_truth()): color_actual = [0, 0, 1, 1] plot_actual = MeshLinePlot(color=color_actual) plot_actual.points = [(m.timestamp - self.first_timestamp, m.distance - 0.1) for m in mc.measures] self.graph.add_plot(plot_actual) if last_mc is not None: plot_next = MeshLinePlot(color=[1, 1, 1, 1]) plot_next.points = [ (last_mc.last_measure().timestamp - self.first_timestamp, last_mc.last_measure().distance), (mc.first_measure().timestamp - self.first_timestamp, mc.first_measure().distance) ] self.graph.add_plot(plot_next) last_mc = mc # plot = MeshLinePlot(color=[1, 1, 1, 1]) # plot.points = [(m.timestamp - self.first_timestamp, m.distance) for m in self.measurements] # self.graph.add_plot(plot) self._keyboard = Window.request_keyboard(self._keyboard_closed, self) self._keyboard.bind(on_key_down=self._on_keyboard_down) self.running = True self.cur_index = -1 self.show_next_image(0) def build(self): flow_layout = FloatLayout() layout = BoxLayout(size=(300, 300), orientation='vertical') # Window.size = (1000, 700) layout.add_widget(self.image) layout.add_widget(self.graph) flow_layout.add_widget(layout) with flow_layout.canvas as canvas: Color(1., 0, 0) Rectangle(size=(1, 10000)) return flow_layout def _keyboard_closed(self): self._keyboard.unbind(on_key_down=self._on_keyboard_down) self._keyboard = None def _on_keyboard_down(self, keyboard, keycode, text, modifiers): if keycode[1] == 'spacebar': self.on_start_stop() elif keycode[1] == 'right': self.move_forward() elif keycode[1] == 'left': self.move_backward() return True def on_start_stop(self): if not self.running: self.running = True self.show_next_image(0) else: self.running = False def move_forward(self): if not self.running: self.cur_index += 4 self.show_next_image(0) def move_backward(self): if not self.running: self.cur_index -= 6 self.show_next_image(0) def show_next_image(self, dt): self.cur_index += 1 if self.cur_index >= len(self.camera_files): if self.restart: self.cur_index = 0 else: self.running = False return 0 self.image.source = os.path.join(self.camera_folder, self.camera_files[self.cur_index]) cur_time = self.get_timestamp(self.cur_index) self.graph.xmin = cur_time - self.first_timestamp - 2 self.graph.xmax = cur_time - self.first_timestamp + 2 #self.graph.export_to_png('C:\\sw\\master\\scenario_snapshots\\export_' + self.camera_files[self.cur_index] + '.png') next_dt = 1 if self.cur_index + 1 < len(self.camera_files): next_time = self.get_timestamp(self.cur_index + 1) next_dt = next_time - cur_time + self.additional_interval if self.running: if self.additional_interval < 0: while self.cur_index < len( self.camera_files) and self.get_timestamp( self.cur_index ) - cur_time < -self.additional_interval: self.cur_index += 1 next_dt = 0.001 if self.running: Clock.schedule_once(self.show_next_image, abs(next_dt)) else: self.cur_index = -1 if self.running: Clock.schedule_once(self.show_next_image, next_dt) if next_dt <= 0: skip_images = int(-next_dt / 0.03) self.cur_index += skip_images Clock.schedule_once(self.show_next_image, 0.001) def get_timestamp(self, index): f = self.camera_files[index] dt = datetime.strptime(f.split('.')[0], '%Y%m%d_%H%M%S_%f') return (dt - datetime(1970, 1, 1)).total_seconds()
class CottrellGraph(CottrellGraphBase, EventDispatcher): """Crée le graphique contenant les courbes de Cottrell en utilisant `kivy.garden.graph`. """ legend = BooleanProperty(True) ticks_labels = BooleanProperty(True) 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) #self._update_ticks_counts = 0 # Pour éviter un clignotement #with self.graph.canvas: # Callback(self._trigger) def update(self, *args): """Met à jour le graphique en redessinant les courbes. """ if self._display_theoric: self.thplot.points = list(zip(self.t, self.I)) if self.thplot not in self.graph.plots: self.graph.add_plot(self.thplot) else: if self.thplot in self.graph.plots: self.graph.remove_plot(self.thplot) if self._display_experimental: self.expplot.points = list(zip(self.expt, self.expI)) if self.expplot not in self.graph.plots: self.graph.add_plot(self.expplot) else: if self.expplot in self.graph.plots: self.graph.remove_plot(self.expplot) self.graph.xmin = float(self.tleft) self.graph.xmax = float(self.tright) self.graph.ymin = float(self.Ibottom) self.graph.ymax = float( self.Itop) if self.Ibottom != self.Itop else 1.0 self.update_ticks() def update_ticks(self, *args): """Met à jour l'échelle. """ width, height = self.graph.get_plot_area_size() self.graph.x_ticks_major = (self.graph.xmax - self.graph.xmin) / (width / 100) self.graph.x_ticks_minor = 10 self.graph.y_ticks_major = (self.graph.ymax - self.graph.ymin) / (height / 50) self.graph.y_ticks_minor = 5 def update_colors(self, *args): theme_cls = App.get_running_app().theme_cls self.graph.label_options['color'] = get_color_from_hex( colors[theme_cls.primary_palette][theme_cls.primary_hue]) self.graph.background_color = get_color_from_hex( colors[theme_cls.theme_style]["Background"]) self.graph.tick_color = get_color_from_hex( colors[theme_cls.accent_palette][theme_cls.accent_hue]) self.graph.border_color = get_color_from_hex( colors[theme_cls.accent_palette][theme_cls.accent_hue]) def get_canvas(self): return self.graph def to_widget(self, x, y, relative=False): """Voir `kivy.widget.Widget.to_widget`. """ return self.graph.to_widget(x, y, relative) def collide_plot(self, x, y): """Détermine si les coordonées tombent dans la zone des courbes. Utilisez `x, y = self.to_widget(x, y, relative=True)` pour d'abord les convertir en coordonées widget si elles sont dans les coordonées de la fenêtre. Paramètres ---------- `x, y` : floats Les coordonnées à tester. """ return self.graph.collide_plot(x, y) def zoom(self, dx, dy, cx, cy): """ Zoom dans le graphique par un facteur. Une valeur de `dx` ou de `dy` supérieure à 1 effectue un zoom, inferieure à 1 effectue un dézoom. Par défaut `dx=1`, `dy=1`. Paramètres ---------- dx : float Facteur de zoom horizontal. dy : float Facteur de zoom vertical. cx : float Abscisse du point sur lequel on zoom. Doit être exprimé dans les coordonnées du widget. cy : float Ordonnée du point sur lequel on zoom. Doit être exprimé dans les coordonnées du widget. Pour convertir le point depuis les coordonnées de la fenêtre dans les coordonnées du widget: `cx, cy = self.graph.to_widget(cx, cy, relative=True)` """ if dx <= 0 or dy <= 0: return if self.Itop == self.Ibottom or self.tleft == self.tright: return dcx, dcy = self.graph.to_data(cx, cy) xratio = (dcx - self.tleft) / (self.tright - self.tleft) yratio = (dcy - self.Ibottom) / (self.Itop - self.Ibottom) xrange = (self.tright - self.tleft) / dx yrange = (self.Itop - self.Ibottom) / dy tleft = dcx - xratio * xrange tright = tleft + xrange Ibottom = dcy - yratio * yrange Itop = Ibottom + yrange self.set_limit_interval(tleft, tright, Ibottom, Itop) self.update()
class CoxGraph(): """Crée le graphique contenant la courbe de Cox en utilisant `kivy.garden.graph`. """ 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 update(self, *args): """Met à jour l'affichage. """ self.coxplot.points = list(zip(self.x,self.cox)) self.graph.xmin = min(self.x) self.graph.xmax = max(self.x) self.update_ticks() def update_ticks(self, *args): """Met à jour l'échelle. """ width, height = self.graph.get_plot_area_size() self.graph.x_ticks_major = (self.graph.xmax-self.graph.xmin)/(width/100) self.graph.x_ticks_minor = 10 self.graph.y_ticks_major = (self.graph.ymax-self.graph.ymin)/(height/50) self.graph.y_ticks_minor = 5 def get_canvas(self): return (self.graph)
def playVideo(self,FourthScreen): #get data for patient with open('choosePatient.txt','r') as f: patientName=f.read() # data = data.split(',') fileName ='videos/' + patientName + ".mp4" dataMatrix1 = genfromtxt('DemoEEGFile.txt') x = dataMatrix1[:,0] x = x - 5.539 y = dataMatrix1[:,1] xmin = math.trunc(x[0]) ymin = math.trunc(min(y))#math.trunc(y[0]) xmax = xmin+1 xGlobalmax = math.trunc(x[len(x)-1]) ymax = math.trunc(max(y))#math.trunc(y[len(y)-1]) # create buttons btnRight = Button(text='Scroll', size_hint=(.05,1),pos_hint={'x':0.45})#,'y':0}) btnLeft = Button(text='Scroll', size_hint=(.05,1),pos_hint={'left':1}) FourthScreen.add_widget(btnRight) FourthScreen.add_widget(btnLeft) # create graph graph = Graph() plot = LinePlot(mode='line_strip',color=[1,0,0,1]) plot.points = [(x[i],y[i]) for i in xrange(len(x))] graph.add_plot(plot) graph.x_ticks_major=.5 graph.xmin=xmin graph.xmax=xmax graph.ymin=ymin graph.ymax=ymax graph.y_ticks_major=10 graph.xlabel='Time (min)' graph.ylabel='Brain Wave Amplitude (mV)' graph.y_grid = True graph.x_grid = True graph.size_hint=(0.4,0.9) graph.x_grid_label=True graph.y_grid_label=True # create video player video = VideoPlayer(source=fileName) video.play=False video.size_hint=(0.5,0.9) video.pos_hint={'right':1,'top':1} graph.pos_hint={'x':0.05,'top':1} def moveRight(obj): global xmin global xmax global xGlobalmax xmin=xmin+.5 xmax=xmax+.5 graph.xmin=xmin graph.xmax=xmax percent = 1-(xGlobalmax-xmin)/xGlobalmax video.seek(percent) btnRight.bind(on_release=moveRight) def moveLeft(obj): global xmin global xmax global xGlobalmax xmin=xmin-.5 xmax=xmax-.5 graph.xmin=xmin graph.xmax=xmax percent = 1-(xGlobalmax-xmin)/xGlobalmax video.seek(percent) btnLeft.bind(on_release=moveLeft) FourthScreen.add_widget(graph) FourthScreen.add_widget(video)
def __init__(self, **kwargs): super(FourthScreen, self).__init__(**kwargs) # create buttons btnRight = Button(text='Scroll', size_hint=(.05,1),pos_hint={'x':0.45})#,'y':0}) btnLeft = Button(text='Scroll', size_hint=(.05,1),pos_hint={'left':1}) self.add_widget(btnRight) self.add_widget(btnLeft) # create graph graph = Graph() plot = LinePlot(mode='line_strip',color=[1,0,0,1]) plot.points = [(x[i],y[i]) for i in xrange(len(x))] graph.add_plot(plot) graph.x_ticks_major=.5 graph.xmin=xmin graph.xmax=xmax graph.ymin=ymin graph.ymax=ymax graph.y_ticks_major=10 graph.xlabel='Time (min)' graph.ylabel='Brain Wave Amplitude (mV)' graph.y_grid = True graph.x_grid = True graph.size_hint=(0.4,0.9) graph.x_grid_label=True graph.y_grid_label=True # create video player video = VideoPlayer(source='Momona.mp4') video.play=False video.size_hint=(0.5,0.9) video.pos_hint={'right':1,'top':1} graph.pos_hint={'x':0.05,'top':1} def moveRight(obj): global xmin global xmax global xGlobalmax xmin=xmin+.5 xmax=xmax+.5 graph.xmin=xmin graph.xmax=xmax percent = 1-(xGlobalmax-xmin)/xGlobalmax video.seek(percent) btnRight.bind(on_release=moveRight) def moveLeft(obj): global xmin global xmax global xGlobalmax xmin=xmin-.5 xmax=xmax-.5 graph.xmin=xmin graph.xmax=xmax percent = 1-(xGlobalmax-xmin)/xGlobalmax video.seek(percent) btnLeft.bind(on_release=moveLeft) self.add_widget(graph) self.add_widget(video)
class MTSPGraph(BoxLayout): green = [0, 1, 0, 1] blue = [0, 0, 1, 1] def __init__(self): super(MTSPGraph, self).__init__() self.graph = Graph( xlabel="Distance", ylabel="Cost", x_ticks_minor=0, x_ticks_major=10000, y_ticks_minor=0, y_ticks_major=100, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0, xmax=200000, ymin=0, ymax=2000, size=(1200, 800) ) self.plot = [] self.plot.append(MeshLinePlot(color=self.green)) self.plot.append(MeshLinePlot(color=self.blue)) self.plot[1]._set_mode('points') self.orientation = 'vertical' self.add_widget(self.graph) def generate_color(self, n): return [random() for _ in range(4)] def add_datas(self, fronts, end=False): if end: for plot in self.plot: self.graph.remove_plot(plot) self.plot = [] ## add first pareto front self.plot.append(MeshLinePlot(color=self.green)) else: self.plot[0].points.clear() self.plot[1].points.clear() for individual in fronts[0].getIndividuals(): self.plot[0].points.append((individual.getDistanceValue(), individual.getCostValue())) ## add all other fronts if end: for i in range(1, len(fronts)): self.plot.append(MeshLinePlot(color=self.generate_color(i))) #self.plot[i]._set_mode('points') for individual in fronts[i].getIndividuals(): self.plot[i].points.append((individual.getDistanceValue(), individual.getCostValue())) else: for i in range(1, len(fronts)): for individual in fronts[i].getIndividuals(): self.plot[1].points.append((individual.getDistanceValue(), individual.getCostValue())) for plot in self.plot: self.graph.add_plot(plot)
class RealtimeGCCNMFInterfaceWindow(GridLayout): def __init__(self, params, gccPHATHistory, tdoaHistory, inputSpectrogramHistory, outputSpectrogramHistory, coefficientMaskHistories, togglePlayAudioProcessQueue, togglePlayAudioProcessAck, togglePlayGCCNMFProcessQueue, togglePlayGCCNMFProcessAck, tdoaParamsGCCNMFProcessQueue, tdoaParamsGCCNMFProcessAck): super(RealtimeGCCNMFInterfaceWindow, self).__init__() self.numTDOAs = params.numTDOAs self.tdoaIndexes = np.arange(self.numTDOAs) self.targetTDOAIndex = self.numTDOAs / 2.0 self.tdoaHistory = tdoaHistory self.gccPHATHistory = gccPHATHistory self.inputSpectrogramHistory = inputSpectrogramHistory self.outputSpectrogramHistory = outputSpectrogramHistory self.coefficientMaskHistories = coefficientMaskHistories self.togglePlayAudioProcessQueue = togglePlayAudioProcessQueue self.togglePlayAudioProcessAck = togglePlayAudioProcessAck self.togglePlayGCCNMFProcessQueue = togglePlayGCCNMFProcessQueue self.togglePlayGCCNMFProcessAck = togglePlayGCCNMFProcessAck self.tdoaParamsGCCNMFProcessQueue = tdoaParamsGCCNMFProcessQueue self.tdoaParamsGCCNMFProcessAck = tdoaParamsGCCNMFProcessAck # self.toggleSeparationGCCNMFProcessQueue = toggleSeparationGCCNMFProcessQueue # self.toggleSeparationGCCNMFProcessAck = toggleSeparationGCCNMFProcessAck self.timer = Clock.schedule_interval(self.updateSlider, 0.01) self.tdoas = np.arange(self.numTDOAs).astype(np.float32) self.tdoaT = np.arange(self.numTDOAs) self.initWindow() def initWindow(self): self.rows = 4 self.targetModeTDOASlider = Slider(orientation='horizontal', min=0, max=100, value=50) self.targetModeWindowTDOASlider = Slider(orientation='horizontal', min=0, max=100, value=50) self.targetModeWindowTDOASlider.bind(value=self.OnSliderValueChange) self.playIconString = 'Play' self.pauseIconString = 'Pause' self.playButton = Button(text='Play') self.playButton.bind(on_press=self.togglePlay) self.initGraph() self.add_widget(self.targetModeWindowTDOASlider) self.add_widget(self.playButton) def initGraph(self): self.graph = Graph(xlabel='TDOAs', ylabel='Y', x_ticks_minor=10, x_ticks_major=10, y_ticks_major=0.5, x_grid_label=False, padding=5, x_grid=False, y_grid=False, xmin=0, xmax=self.numTDOAs, ymin=-0.5, ymax=1.5) self.gaussianplot = MeshLinePlot( color=[1, 0, 0, 1]) # 사용자가 선택하는 target TDOA 정규 분포 self.calculated_plot = MeshLinePlot( color=[0, 1, 0, 1]) # gccPHAT으로 분석된 TDOA plot self.graph.add_plot(self.gaussianplot) self.add_widget(self.graph) def OnSliderValueChange(self, instance, value): self.tdoaRegionChanged() def queueParams(self, queue, ack, params, label='params'): ack.clear() logging.debug('GCCNMFInterface: putting %s' % label) queue.put(params) logging.debug('GCCNMFInterface: put %s' % label) ack.wait() logging.debug('GCCNMFInterface: ack received') def updateTogglePlayParamsAudioProcess(self, playing): self.queueParams(self.togglePlayAudioProcessQueue, self.togglePlayAudioProcessAck, {'start' if playing else 'stop': ''}, 'audioProcessParameters') def updateTogglePlayParamsGCCNMFProcess(self): self.queueParams(self.togglePlayGCCNMFProcessQueue, self.togglePlayGCCNMFProcessAck, { 'numTDOAs': self.numTDOAs, 'dictionarySize': 256 }, 'gccNMFProcessTogglePlayParameters') def togglePlay(self, value): playing = self.playButton.text == self.playIconString self.playButton.text = (self.pauseIconString if playing else self.playIconString) logging.info('1111GCCNMFInterface: setting playing: %s' % playing) if playing: self.timer() self.tdoaRegionChanged() self.updateTogglePlayParamsGCCNMFProcess() self.updateTogglePlayParamsAudioProcess(playing) else: self.updateTogglePlayParamsAudioProcess(playing) self.timer.cancel() def getTDOA(self): tdoa = self.targetModeWindowTDOASlider.value / 100.0 * self.numTDOAs return tdoa def getBeta(self): lnBeta = 50 / 100.0 # 임의 값 self.targetModeWindowBetaSlider.value() / 100.0 lnBeta *= 10.0 lnBeta -= 5.0 beta = np.exp(lnBeta) return beta def getNoiseFloor(self): noiseFloorValue = 0 / 100.0 # 임의 값self.targetModeWindowNoiseFloorSlider.value() / 100.0 return noiseFloorValue def getWindowWidth(self): # windowWidth = self.targetModeWindowWidthSlider.value / 100.0 * self.numTDOAs windowWidth = 50 / 100.0 * self.numTDOAs # 임의 값 return windowWidth def tdoaRegionChanged(self): self.queueParams( self.tdoaParamsGCCNMFProcessQueue, self.tdoaParamsGCCNMFProcessAck, { 'targetTDOAIndex': self.getTDOA(), 'targetTDOAEpsilon': self.getWindowWidth(), # 'targetTDOAEpsilon': self.targetWindowFunctionPlot.getWindowWidth(), # targetTDOAEpsilon, 'targetTDOABeta': self.getBeta(), 'targetTDOANoiseFloor': self.getNoiseFloor() }, 'gccNMFProcessTDOAParameters (region)') def updateSlider(self, value): sliderValue = self.tdoaHistory.get()[0] / (self.numTDOAs - 1) * 100 self.targetModeTDOASlider.value = int(sliderValue) self.updatePlot() def updatePlot(self): self.graph.remove_plot(self.gaussianplot) # 기존의 plot 삭제, gui로 보기 좋도록 self.graph.remove_plot(self.calculated_plot) # 삭제 mu = self.getTDOA() alpha = self.getWindowWidth() beta = self.getBeta() noiseFloor = self.getNoiseFloor() data = generalizedGaussian(self.tdoas, alpha, beta, mu) # 이것이 현재 들리는 소리의 tdoa를 표현 data -= min(data) data = data / max(data) * (1 - noiseFloor) + noiseFloor self.gaussianplot.points = [(x, data[x]) for x in range(0, self.numTDOAs)] self.graph.add_plot(self.gaussianplot) gccPHATValues = np.squeeze(np.mean(self.gccPHATHistory.values, axis=-1)) gccPHATValues -= min(gccPHATValues) gccPHATValues /= max(gccPHATValues) self.calculated_plot.points = [(x, gccPHATValues[x]) for x in range(gccPHATValues.shape[0])] self.graph.add_plot(self.calculated_plot)
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.deviceSelectors = ( self.ids[ 'joint_selector' ], self.ids[ 'axis_selector' ] ) self.deviceEntries = [ DropDown() for selector in self.deviceSelectors ] for index in range( len(self.deviceEntries) ): def SelectEntry( instance, name, index=index ): self.SetDevice( index, name ) self.deviceEntries[ index ].bind( on_select=SelectEntry ) self.deviceSelectors[ index ].bind( on_release=self.deviceEntries[ index ].open ) dataGraph = self.ids[ 'data_graph' ] measure_range = self.ids[ 'measure_slider' ].range GRAPH_PROPERTIES = { 'xlabel':'Last Samples', 'x_ticks_minor':5, 'x_ticks_major':25, 'y_ticks_major':0.25, 'y_grid_label':True, 'x_grid_label':True, 'padding':5, 'x_grid':True, 'y_grid':True, 'xmin':0, 'xmax':len(self.INITIAL_VALUES) - 1, 'ymin':measure_range[ 0 ], 'ymax':measure_range[ 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', **GRAPH_PROPERTIES ) axisPositionPlot = SmoothLinePlot( color=[ 0, 0, 1, 1 ] ) axisPositionGraph.add_plot( axisPositionPlot ) self.dataPlots.append( RobRehabGUI.DataPlot( axisPositionPlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_POSITION ) ) axisVelocityPlot = SmoothLinePlot( color=[ 0, 1, 0, 1 ] ) axisPositionGraph.add_plot( axisVelocityPlot ) self.dataPlots.append( RobRehabGUI.DataPlot( axisVelocityPlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_VELOCITY ) ) 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 ) ) refVelocityPlot = SmoothLinePlot( color=[ 0, 0.5, 0, 1 ] ) axisPositionGraph.add_plot( refVelocityPlot ) self.dataPlots.append( RobRehabGUI.DataPlot( refVelocityPlot, self.INITIAL_VALUES[:], self.setpoints, DOF_VELOCITY ) ) axisAccelerationPlot = SmoothLinePlot( color=[ 1, 0, 0, 1 ] ) axisPositionGraph.add_plot( axisAccelerationPlot ) self.dataPlots.append( RobRehabGUI.DataPlot( axisAccelerationPlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_ACCELERATION ) ) dataGraph.add_widget( axisPositionGraph ) dataGraph.add_widget( Label( size_hint_y=0.05 ) ) axisForceGraph = Graph( ylabel='Torque', **GRAPH_PROPERTIES ) axisForcePlot = SmoothLinePlot( color=[ 1, 0, 0, 1 ] ) axisForceGraph.add_plot( axisForcePlot ) self.dataPlots.append( RobRehabGUI.DataPlot( axisForcePlot, self.INITIAL_VALUES[:], self.axisMeasures, DOF_FORCE ) ) dataGraph.add_widget( axisForceGraph ) Clock.schedule_interval( self.NetworkUpdate, self.UPDATE_INTERVAL / 2 ) Clock.schedule_interval( self.GraphUpdate, self.UPDATE_INTERVAL * 2 ) Clock.schedule_interval( self.SliderUpdate, self.UPDATE_INTERVAL )
class Eyeball_DAQApp(App): #========================= def _update_pos(self, dt): if self.ser!=0: try: dat = get_nmea(self) e = dat['e_1'] n = dat['n_1'] z = dat['alt'] self.textinput3.text = 'Easting: '+str(e)+', Northing: '+str(n)+', Elevation: '+str(z)+'\n' except: self.textinput3.text = 'Easting: NaN, Northing: NaN, Elevation: NaN\n' #========================= def _update_time(self, dt): self.item.title = 'Current time is '+time.asctime() #========================= def _draw_me(self, dt): try: e = self.textinput3.text.split(':')[1].split(',')[0] n = self.textinput3.text.split(':')[2].split(',')[0] self.plot.points.append((float(e),float(n))) self.graph.xmax = 10+max(self.plot.points)[0] self.graph.xmin = min(self.plot.points)[0]-10 self.graph.ymax = 10+max(self.plot.points)[1] self.graph.ymin = min(self.plot.points)[1]-10 except: pass #xmax = random.randint(10, 100) #self.plot.points = [(x, sin(x / 10.)) for x in range(0, xmax)] #self.graph.xmax = xmax #========================= def build(self): self.ser = init_serial(self) root = Accordion(orientation='horizontal') self.item = AccordionItem(title='Current time is '+time.asctime()) image = CameraWidget(size_hint = (2.0, 1.0)) # log layout = GridLayout(cols=1) self.textinput = Log(text='Data Acquisition Log\n', size_hint = (0.5, 1.0), markup=True) layout.add_widget(self.textinput) image.textinput = self.textinput # read nav station positions with open('nav_stat_gps.txt') as f: dump = f.read() f.close() dump = dump.split('\n') for k in dump: if k.startswith('e'): ep = float(k.split('=')[1].lstrip()) elif k.startswith('n'): np = float(k.split('=')[1].lstrip()) elif k.startswith('z'): zp = float(k.split('=')[1].lstrip()) # for map #layout.add_widget(Button(text='Map', width=100)) self.graph = Graph(xlabel='E', ylabel='N', x_ticks_minor=1, x_ticks_major=25, y_ticks_major=10, y_ticks_minor=1, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=ep-10, xmax=ep+10, ymin=np-10, ymax=np+10) self.plot = MeshLinePlot(color=[1, 0, 0, 1]) self.plot.points = [(ep,np)] self.graph.add_plot(self.plot) layout.add_widget(self.graph) image.graph1 = self.plot # for quotes self.textinput2 = Log(text='', size_hint = (0.5, 1.0), markup=True) layout.add_widget(self.textinput2) image.textinput2 = self.textinput2 self.textinput3 = Log(text='\n', size_hint = (0.25, 0.25), markup=True) layout.add_widget(self.textinput3) image.textinput3 = self.textinput3 # add image to AccordionItem self.item.add_widget(image) #item.add_widget(self.textinput) self.item.add_widget(layout) Clock.schedule_interval(self._update_pos, 5) Clock.schedule_interval(self._update_time, 1) Clock.schedule_interval(self._draw_me, 10) root.add_widget(self.item) return root #========================= def on_stop(self): # write session log to file with open(os.path.expanduser("~")+os.sep+'log_'+time.asctime().replace(' ','_').replace(':','_')+'.txt','wb') as f: f.write(self.textinput.text) f.close() with open('station_start.txt','rb') as f: st=str(f.read()).split('\n')[0] f.close() countmax=22; counter=0 with open('eyedaq.kv','rb') as oldfile, open('eyedaq_new.kv','wb') as newfile: for line in oldfile: counter += 1 if counter==countmax: newfile.write(" text: '"+st+"'\n") else: newfile.write(line) mv('eyedaq_new.kv','eyedaq.kv') ## close the csv results files #bedf_csv.close() #print "output files closed" # close the serial port if self.ser!=0: self.ser.close() print "=================" print "GPS is closed" print "================="
class Reminder(BoxLayout): def __init__(self, **kwargs): super().__init__(**kwargs) self.app_ = App.get_running_app() # Get the dates clicked self.model_ = self.app_.calendar_.dates_.model_ # Information to be added self.body = self.model_.printSelectedResults() # Layout arrangementw self.orientation = 'vertical' # Elevators information self.layout_comp = BoxLayout(orientation='horizontal', size_hint=(1, 1)) self.layout_map = BoxLayout(orientation='horizontal', size_hint=(1, 1)) self.img_comp_1 = Image(source='component_1.png', keep_ratio=False, size_hint=(1, 1), allow_stretch=False, mipmap=True) self.img_comp_2 = Image(source='component_2.png', keep_ratio=False, size_hint=(1, 1), allow_stretch=False, mipmap=True) self.layout_comp.add_widget(self.img_comp_1) self.layout_comp.add_widget(self.img_comp_2) self.img_map_1 = Image(source='map_kunshan.png', keep_ratio=False, size_hint=(1, 1), allow_stretch=True) self.img_map_2 = Image(source='map_sh.png', keep_ratio=False, size_hint=(1, 1), allow_stretch=True) self.layout_map.add_widget(self.img_map_1) self.layout_map.add_widget( Label(size_hint=(0.1, 1), text='昆\n山\n地\n区\n电\n梯\n分\n布\n图', font_name=font_name, font_size='20sp', color=(0, 0, 0, 1))) self.layout_map.add_widget(self.img_map_2) self.layout_map.add_widget( Label(size_hint=(0.1, 1), text='上\n海\n地\n区\n电\n梯\n分\n布\n图', font_name=font_name, font_size='20sp', color=(0, 0, 0, 1))) self.layout_fig = BoxLayout(orientation='vertical', size_hint=(1, 0.7)) #self.layout_fig.add_widget(self.layout_comp) self.layout_fig.add_widget(self.layout_map) self.add_widget(self.layout_fig) #self.layout_scroll_lb=Label(text=self.body,size_hint=(1,None)) #self.layout_scroll_lb.height=self.layout_scroll_lb.texture_size[1] #self.layout_scroll=ScrollableLabel(text=self.body) #self.layout_scroll.add_widget(self.layout_scroll_lb) #self.layout1_title=Label(text='以下电梯预测将在30天内发生故障:\n'+self.body,font_name=font_name) #self.layout1_title.size=self.layout1_title.texture_size #self.layout1.add_widget(self.layout1_title) #self.layout1.add_widget(self.layout_scroll) # Plots self.graph_theme = { 'label_options': { 'color': (0, 0, 0, 1), # color of tick labels and titles 'bold': True }, 'tick_color': (0, 0, 0, 1) } # ticks and grid self.graph = Graph(xlabel='Current time', ylabel='Maintenance date', x_ticks_major=5, y_ticks_major=5, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=-0, xmax=31, ymin=-0, ymax=31, **self.graph_theme) self.plot = MeshLinePlot(color=[1, 0, 0, 1]) self.best_maint_dates = joblib.load('mon_best_int_np.asv') self.best_maint_dates = self.best_maint_dates[self.model_.month - 1] self.plot.points = [(x + 1, x + 1 + self.best_maint_dates[x]) for x in range(len(self.best_maint_dates))] self.graph.add_plot(self.plot) self.layout_graph = BoxLayout(orientation='vertical', size_hint=(0.7, 1)) self.layout_graph.add_widget( Label(text='本月最优维保日期随时间变化图', font_name=font_name, size_hint=(1, 0.1), font_size='16sp', color=(0, 0, 0, 1))) self.layout_graph.add_widget(self.graph) # Note for user self.layout_info = BoxLayout(orientation='vertical', size_hint=(0.3, 1)) self.layout_info.add_widget( Label( text= '待预防性维护电梯信息:\n设备编号\n设备所在区域类型\n故障信息\n所在城市\n电梯运行速度\n设备型号\n距离上一次维修天数', font_name=font_name, pos_hint={ 'x': 0.5, 'center_y': .5 }, font_size='16sp', color=(0, 0, 0, 1))) self.layout_note = BoxLayout(orientation='vertical', size_hint=(0.5, 0.8)) self.layout_note.add_widget( Button(on_press=self.on_press, text='输出\n电梯\n信息', font_name=font_name, pos_hint={ 'x': .5, 'y': 1 }, size_hint=(0.4, 0.2), font_size='20sp', color=(0, 0, 0, 1), background_color=color_shadow_blue)) self.layout_graph_note = BoxLayout(orientation='horizontal', size_hint=(1, 0.5)) self.layout_graph_note.add_widget(self.layout_graph) self.layout_graph_note.add_widget(self.layout_info) self.layout_graph_note.add_widget(self.layout_note) self.add_widget(self.layout_graph_note) self.layout2 = BoxLayout(orientation='horizontal', size_hint=(1, .15)) self.add_widget(self.layout2) self.layout2.add_widget( Label(text="请按 'ESC'键或点击窗外以关闭窗口", font_name=font_name, font_size='20sp', color=(1, 0, 0, 1))) def on_release(self, event): print("Reminder OK Clicked!") def on_press(self, event): file_name = 'Log-{:}-{:}-{:}.tsv'.format(self.model_.year, self.model_.month, self.model_.day) f = open(file_name, 'w', encoding="utf-8") f.write(self.body) f.close()
class customGraph: def __init__(self): self.graph_theme = { 'label_options': { 'color': rgb('444444'), # color of tick labels and titles 'bold': True }, 'background_color': rgb('b8b7bb'), # back ground color of canvas 'tick_color': rgb('808080'), # ticks and grid 'border_color': rgb('808080') } # border drawn around each graph self.graph_canvas = BoxLayout(orientation='vertical', padding=5) self.graph_rain = Graph(ylabel="rainfall(mm/s)", y_grid_label=True, x_grid_label=True, xmin=0, xmax=10, ymin=0, ymax=5000, x_ticks_major=5, y_ticks_major=2500, x_ticks_minor=1, y_ticks_minor=100, x_grid=True, y_grid=True, padding=5, **self.graph_theme) self.graph_temp = Graph(ylabel="temperature (C)", y_grid_label=True, x_grid_label=True, xmin=0, xmax=10, ymin=0, ymax=50, x_ticks_major=5, y_ticks_major=25, x_ticks_minor=1, y_ticks_minor=5, x_grid=True, y_grid=True, padding=5, **self.graph_theme) self.plot_rain = MeshLinePlot(color=[0, 0, 1, 1]) self.plot_temp = MeshLinePlot(color=[1, 0, 0, 1]) def update_data(self, data): for item in data: print item try: self.graph_rain.remove_plot(self.plot_rain) self.graph_canvas.remove_widget(self.graph_rain) except: pass try: self.graph_temp.remove_plot(self.plot_temp) self.graph_canvas.remove_widget(self.graph_temp) except: pass if data[0]: max_value = max(data[0]) self.resize_graph(self.graph_rain, max_value) self.plot_rain.points = [(float(x), float(y)) for x, y in enumerate(data[0])] self.graph_rain.add_plot(self.plot_rain) self.graph_canvas.add_widget(self.graph_rain) if data[1]: self.plot_temp.points = [(float(x), float(y)) for x, y in enumerate(data[1])] self.graph_temp.add_plot(self.plot_temp) self.graph_canvas.add_widget(self.graph_temp) def resize_graph(self, graph, value): # print "value" + str(self.graph_rain.ymax) self.graph_rain.ymax = int(value) + 10 self.graph_rain.y_ticks_major = int(self.graph_rain.ymax / 2) def get_graph(self): return self.graph_canvas
class PlotScreen(Screen): def __init__(self, *args, **kwargs): super(PlotScreen, self).__init__(*args, **kwargs) self.graph_figure = None self.colors = itertools.cycle( [rgb('7dac9f'), rgb('dc7062'), rgb('66a8d4'), rgb('e5b060')]) 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 destroy(self): """ This must be called before a new graph is plotted. """ self.remove_widget(self.graph_figure) self.graph_figure = None Logger.info( 'PlotScreen: Destroyed the child widget (the plot/graph) of PlotScreen' )
class GraphLinearRegression(LinearRegression): """Crée le graphique des courbes de régression linéaire. """ 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 update(self, *args): """Met à jour l'affichage des courbes de régression linéaire et le calcul du coefficient de diffusion expérimental. """ self.logexp_and_linear_curves_tab(self.t, self.I) _, intercept = self.linregress() self.Dexp = self.calculate_D(intercept, self.n, self.S, self.C) self.linlogexpplot.label = "Régression linéaire\nD=" + str(self.Dexp) self.logexpplot.points = list(zip(self.logexpt, self.logexpI)) self.linlogexpplot.points = list(zip(self.logexpt, self.linlogexpI)) self.graph.xmin = float(min(self.logexpt)) self.graph.xmax = float(max(self.logexpt)) self.graph.ymin = float(min(self.logexpI)) self.graph.ymax = float(max(self.logexpI)) self.update_ticks() def update_ticks(self, *args): """Met à jour l'échelle. """ width, height = self.graph.get_plot_area_size() self.graph.x_ticks_major = (self.graph.xmax - self.graph.xmin) / (width / 100) self.graph.x_ticks_minor = 10 self.graph.y_ticks_major = (self.graph.ymax - self.graph.ymin) / (height / 50) self.graph.y_ticks_minor = 5 def update_colors(self, *args): theme_cls = App.get_running_app().theme_cls self.graph.label_options['color'] = get_color_from_hex( colors[theme_cls.primary_palette][theme_cls.primary_hue]) self.graph.background_color = get_color_from_hex( colors[theme_cls.theme_style]["Background"]) self.graph.tick_color = get_color_from_hex( colors[theme_cls.accent_palette][theme_cls.accent_hue]) self.graph.border_color = get_color_from_hex( colors[theme_cls.accent_palette][theme_cls.accent_hue]) def get_canvas(self): return self.graph
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)
class Stats(BoxLayout): def __init__(self, **kwargs): super(Stats, self).__init__(**kwargs) self.flag = 0 # flag = 1: Daily cost # flag = 2: Weekly cost # flag = 3: Monthly cost # flag = 4: Daily mistakes # flag = 5: Weekly mistakes # flag = 6: Monthly mistakes # flag = 7: Omission Category # flag = 8: Commission Category self.calculate_day_cost() self.graph_theme = { 'label_options': { 'color': (182 / 255.0, 174 / 255.0, 183 / 255.0, 1), # color of tick labels and titles 'bold': False }, 'tick_color': (1, 1, 1, 1), # ticks and grid 'border_color': (182 / 255.0, 174 / 255.0, 183 / 255.0, 1) } # border drawn around each graph # Monthly cost graph self.graph1 = Graph(xlabel='Months', ylabel='Costs', size_hint=(0.7, 0.9), pos_hint={ 'center_x': .5, 'center_y': 0.5 }, x_ticks_major=5, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=5, xmin=0, xmax=12, ymin=0, ymax=80, **self.graph_theme) # Weekly cost graph self.graph2 = Graph(xlabel='Weeks', ylabel='Costs', size_hint=(0.7, 0.9), pos_hint={ 'center_x': .5, 'center_y': 0.5 }, x_ticks_major=5, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=5, xmin=0, xmax=20, ymin=0, ymax=80, **self.graph_theme) # Daily cost graph self.graph8 = Graph(xlabel='Days', ylabel='Costs', size_hint=(0.7, 0.9), pos_hint={ 'center_x': .5, 'center_y': 0.5 }, x_ticks_major=5, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=5, xmin=0, xmax=150, ymin=0, ymax=80, **self.graph_theme) # Monthly mistakes graph self.graph5 = Graph(xlabel='Months', ylabel='Mistakes', size_hint=(0.7, 0.9), pos_hint={ 'center_x': .5, 'center_y': 0.5 }, x_ticks_major=5, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, xmin=0, xmax=12, ymin=0, ymax=5, **self.graph_theme) # Weekly mistakes graph self.graph6 = Graph(xlabel='Weeks', ylabel='Mistakes', size_hint=(0.7, 0.9), pos_hint={ 'center_x': .5, 'center_y': 0.5 }, x_ticks_major=5, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, xmin=0, xmax=25, ymin=0, ymax=5, **self.graph_theme) # Daily mistakes graph self.graph7 = Graph(xlabel='Days', ylabel='Mistakes', size_hint=(0.7, 0.9), pos_hint={ 'center_x': .5, 'center_y': 0.5 }, x_ticks_major=5, y_ticks_major=1, y_grid_label=True, x_grid_label=True, padding=5, xmin=0, xmax=150, ymin=0, ymax=5, **self.graph_theme) def make_pairs(self, list1, list2): points = [] for (month, cost) in zip(list1, list2): points.append((month, cost)) return points def calculate_day_cost(self): self.ids['opportunity_cost'].text = "Total cost: $" + str( get_total_cost()) 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 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 get_om_cates(self): if self.flag == 7: return self.flag = 7 all_om_verbs = get_all_verbs(True) self.ids['graph2'].clear_widgets() scroll = ScrollView() grid = GridLayout(id='grid', size_hint_y=None, cols=1, row_default_height='30dp', row_force_default=True, spacing=20, padding=20) grid.bind(minimum_height=grid.setter('height')) scroll.add_widget(grid) self.ids['graph2'].add_widget(scroll) for (name, times) in zip(all_om_verbs, get_verb_graph(True)): label_om = CateEntry(name=name, times=str(times)) # print(name) # print(times) grid.add_widget(label_om) def get_cm_cates(self): if self.flag == 8: return self.flag = 8 all_cm_verbs = get_all_verbs(False) self.ids['graph2'].clear_widgets() scroll = ScrollView() grid = GridLayout(id='grid', size_hint_y=None, cols=1, row_default_height='30dp', row_force_default=True, spacing=20, padding=20) grid.bind(minimum_height=grid.setter('height')) scroll.add_widget(grid) self.ids['graph2'].add_widget(scroll) for (name, times) in zip(all_cm_verbs, get_verb_graph(False)): label_om = CateEntry(name=name, times=str(times)) # print(name) # print(times) grid.add_widget(label_om) 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 get_monthly_mistakes(self): if self.flag == 6: return self.flag = 6 month_list = get_all_months() month_om_cost = get_monthly_mistake_tuple()[0] month_cm_cost = get_monthly_mistake_tuple()[1] points_om_list = self.make_pairs(month_list, month_om_cost) points_cm_list = self.make_pairs(month_list, month_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 # month_mistakes = get_monthly_mistake_num() # points_list = self.make_pairs(month_list, month_mistakes) # print(points_list) plot = SmoothLinePlot(color=[1, 0, 0, 1]) self.graph5.add_plot(plot_om) self.graph5.add_plot(plot_cm) self.ids['graph3'].remove_widget(self.graph7) self.ids['graph3'].remove_widget(self.graph6) self.ids['graph3'].add_widget(self.graph5) 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)
class PidLayout(TabDrawerItem, Receiver): def __init__(self, tree, **kwargs): # make sure we aren't overriding any important functionality super(PidLayout, self).__init__(**kwargs) self.text = tree[0] self.mys = () for values in tree[1]: self.mys += (MyS(values), ) self.bm = BoxLayout( orientation='vertical', spacing=10, padding=10, ) self.bm.add_widget(self.build_bouton_layout(tree[2])) self.bm.add_widget(self.build_graph(tree[2])) self.add_widget(self.bm) #APP.add_receiver( self, self.text ) self.key = self.text def on_menu(self, *args): if self.menu: for s in self.mys: self.bm.add_widget(s) else: for s in self.mys: self.bm.remove_widget(s) def build_graph(self, tree): # example of a custom theme graph_theme = { 'label_options': { 'color': (0.27, 0.27, 0.27, 1), # color of tick labels and titles 'bold': True }, 'background_color': (0.97, 0.97, 0.95, 1), # back ground color of canvas 'tick_color': (0.5, 0.5, 0.5, 1), # ticks and grid 'border_color': (0.5, 0.5, 0.5, 1) # border drawn around each graph } self.graph = Graph(xlabel='Seconde', ylabel='Apples', x_ticks_minor=0.5, x_ticks_major=1, y_ticks_minor=1, y_ticks_major=10, y_grid_label=True, x_grid_label=True, padding=5, xlog=False, ylog=False, x_grid=True, y_grid=True, xmin=-3, xmax=0, ymin=-30, ymax=30, **graph_theme) self.dpoints = [] for nom, couleur in tree: self.dpoints.append((nom, MeshLinePlot(color=couleur))) for dpoints in self.dpoints: self.graph.add_plot(dpoints[1]) #self.lpoints = [[0,0],[0,0],[0,0],[0,0],[0,0],[0,0]] self.lpoints = [] return self.graph def update_points(self, points): # points sous forme ( x, y1, y2,...) #print self.text + str(points) # passe le temps de ms en s #points[0] = points[0]/1000 # Ajoute les derniers points a la liste temporaire self.lpoints.append(points) # trie la liste self.lpoints.sort(key=lambda x: x[0]) temps = self.lpoints[-1][0] # supprime les valeurs de plus de 3s while self.lpoints[0][0] < temps - 3000: del self.lpoints[0] #print self.lpoints for i in range(0, len(self.dpoints)): self.dpoints[i - 1][1].points = () # pour chaque point de la liste for point in self.lpoints: # les range dans leurs listes de points sous forme (x,y) for i in range(1, len(point)): self.dpoints[i - 1][1].points.append( ((point[0] - temps) / 1000, point[i] / 10 if i > 1 else point[i])) def courbe_visibility(self, bout): if bout.state is 'normal': self.graph.add_plot(self.dpoints[bout.index][1]) bout.background_color = bout.couleur + (1, ) else: self.graph.remove_plot(self.dpoints[bout.index][1]) bout.background_color = bout.couleur + (0.5, ) def build_bouton_layout(self, tree): bl = BoxLayout( size_hint=(1, None), orientation='horizontal', spacing=10, height=30, ) i = 0 for nom, couleur in tree: bl.add_widget(self.build_bouton(nom, couleur, i)) i += 1 return bl def build_bouton(self, nom, couleur, i): b = ToggleButton(text=nom, background_normal="", background_down="") b.nom = nom b.index = i b.couleur = couleur b.background_color = b.couleur + (1, ) b.bind(on_release=self.courbe_visibility) return b def on_msg_received(self, *args): #print self.msg_received msg = [float(x) for x in self.msg_received.split()] self.update_points(msg)
class Eyeball_DAQApp(App): #========================= def _update_pos(self, dt): with open('C:\Users\User\Desktop\capture.txt') as f: last = f.readline().split('\r')[-2] f.close() last = last.split('99=')[1] if ~last.startswith(' '): sd = float(last.split(';')[0].lstrip())/1000 ha = 0.0009*float(last.split(';')[1].lstrip())/10 va = 0.0009*float(last.split(';')[2].lstrip())/10 ha = (ha - self.hca) % 360 Za = va*0.0174532925 n = self.np + sd * sin(Za) * cos(ha*0.0174532925) z = self.zp + sd * cos(Za) e = self.ep + sd * sin(Za) * sin(ha*0.0174532925) self.textinput3.text = 'Easting: '+str(e)+', Northing: '+str(n)+', Elevation: '+str(z)+'\n' #========================= def _update_time(self, dt): self.item.title = 'Current time is '+time.asctime() #========================= def _draw_me(self, dt): e = self.textinput3.text.split(':')[1].split(',')[0] n = self.textinput3.text.split(':')[2].split(',')[0] self.plot.points.append((float(e),float(n))) self.graph.xmax = 5+max(self.plot.points)[0] self.graph.xmin = min(self.plot.points)[0]-5 self.graph.ymax = 5+max(self.plot.points)[1] self.graph.ymin = min(self.plot.points)[1]-5 #xmax = random.randint(10, 100) #self.plot.points = [(x, sin(x / 10.)) for x in range(0, xmax)] #self.graph.xmax = xmax #========================= def build(self): root = Accordion(orientation='horizontal') self.item = AccordionItem(title='Current time is '+time.asctime()) image = CameraWidget(size_hint = (2.0, 1.0)) # log layout = GridLayout(cols=1) self.textinput = Log(text='Data Acquisition Log\n', size_hint = (0.5, 1.0), markup=True) layout.add_widget(self.textinput) image.textinput = self.textinput # read nav station positions with open('nav_stat.txt') as f: dump = f.read() f.close() dump = dump.split('\n') for k in dump: if k.startswith('e'): self.ep = float(k.split('=')[1].lstrip()) elif k.startswith('n'): self.np = float(k.split('=')[1].lstrip()) elif k.startswith('z'): self.zp = float(k.split('=')[1].lstrip()) elif k.startswith('hca'): self.hca = float(k.split('=')[1].lstrip()) # for map #layout.add_widget(Button(text='Map', width=100)) self.graph = Graph(xlabel='E', ylabel='N', x_ticks_minor=1, x_ticks_major=25, y_ticks_major=10, y_ticks_minor=1, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=self.ep-5, xmax=self.ep+5, ymin=self.np-5, ymax=self.np+5) self.plot = MeshLinePlot(color=[1, 0, 0, 1]) self.plot.points = [(self.ep,self.np)] self.graph.add_plot(self.plot) layout.add_widget(self.graph) image.graph1 = self.plot # for quotes self.textinput2 = Log(text='', size_hint = (0.5, 1.0), markup=True) layout.add_widget(self.textinput2) image.textinput2 = self.textinput2 self.textinput3 = Log(text='\n', size_hint = (0.25, 0.25), markup=True) layout.add_widget(self.textinput3) image.textinput3 = self.textinput3 # add image to AccordionItem self.item.add_widget(image) #item.add_widget(self.textinput) self.item.add_widget(layout) Clock.schedule_interval(self._update_pos, 1) Clock.schedule_interval(self._update_time, 1) Clock.schedule_interval(self._draw_me, 2) root.add_widget(self.item) return root #========================= def on_stop(self): # write session log to file with open(os.path.expanduser("~")+os.sep+'log_'+time.asctime().replace(' ','_').replace(':','_')+'.txt','wb') as f: f.write(self.textinput.text) f.close() with open('station_start.txt','rb') as f: st=str(f.read()).split('\n')[0] f.close() countmax=22; counter=0 with open('eyedaq.kv','rb') as oldfile, open('eyedaq_new.kv','wb') as newfile: for line in oldfile: counter += 1 if counter==countmax: newfile.write(" text: '"+st+"'\n") else: newfile.write(line) mv('eyedaq_new.kv','eyedaq.kv')
class Specimen(BoxLayout): def __init__(self, **kwargs): super(Specimen, self).__init__(**kwargs) self.max_displacement = 4.0 self.tl = TLoop() # set the keyword parameters (to replace the default values) for key, value in kwargs.iteritems(): setattr(self, key, value) self.add_graph() self.add_break_line() self.x_current = 53. self.selected = False self.x_coord = np.linspace(0, self.tl.ts.L_x, self.tl.ts.n_e_x + 1) self.x_ip_coord = np.repeat(self.x_coord, 2)[1:-1] def add_graph(self): self.graph = Graph( y_grid_label=False, x_grid_label=False, padding=5, xmin=0, xmax=100, ymin=0, ymax=30) self.matrix = FilledRect(xrange=[10, 50], yrange=[5, 25], color=[255, 255, 255]) self.reinf = FilledRect(xrange=[10, 50], yrange=[13, 17], color=[255, 0, 0]) self.controller = FilledRect(xrange=[50, 56], yrange=[12, 18], color=[0, 0, 255]) self.graph.add_plot(self.matrix) self.graph.add_plot(self.reinf) self.graph.add_plot(self.controller) self.add_widget(self.graph) def add_break_line(self): break_line3 = LinePlot( color=[0, 0, 0], width=4) break_line3.points = [ (30, 2), (30, 9), (28, 12), (32, 18), (30, 21), (30, 28)] self.graph.add_plot(break_line3) @property def f_u_wid(self): graph = Graph(xlabel='displacement', ylabel='force', x_ticks_minor=5, x_ticks_major=1, y_ticks_major=100, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0, xmax=self.max_displacement, ymin=-100, ymax=500) self.f_u_line = MeshLinePlot(color=[1, 1, 1, 1]) self.f_u_line.points = [(0, 0)] graph.add_plot(self.f_u_line) return graph @property def eps_sig_wid(self): graph = Graph(xlabel='slip', ylabel='bond', x_ticks_minor=5, x_ticks_major=0.5, y_ticks_major=0.2, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=-0.0 * self.max_displacement, xmax=0.8 * self.max_displacement, ymin=-1, ymax=1) self.eps_sig_line = MeshLinePlot(color=[1, 1, 1, 1]) self.eps_sig_line.points = [(0, 0)] graph.add_plot(self.eps_sig_line) return graph @property def shear_flow_wid(self): graph = Graph(xlabel='length', ylabel='shear flow', background_color=[0, 0, 0, 1], x_ticks_major=100., y_ticks_major=0.2, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0.0, xmax=self.tl.ts.L_x, ymin=-1, ymax=1) self.shear_flow_line = MeshLinePlot(color=[1, 1, 1, 1]) self.shear_flow_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) graph.add_plot(self.shear_flow_line) return graph @property def disp_slip_wid(self): graph = Graph(xlabel='length', ylabel='displacement', background_color=[0, 0, 0, 1], x_ticks_major=100., y_ticks_major=1.0, y_grid_label=True, x_grid_label=True, padding=5, x_grid=True, y_grid=True, xmin=0.0, xmax=self.tl.ts.L_x, ymin=0., ymax=self.max_displacement) self.reinf_disp_line = MeshLinePlot(color=[1, 1, 1, 1]) self.reinf_disp_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) self.matrix_disp_line = MeshLinePlot(color=[1, 1, 1, 1]) self.matrix_disp_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) self.slip_line = MeshLinePlot(color=[1, 1, 1, 1]) self.slip_line.points = self.list_tuple( self.x_coord, np.zeros_like(self.x_coord)) graph.add_plot(self.reinf_disp_line) graph.add_plot(self.matrix_disp_line) graph.add_plot(self.slip_line) return graph @staticmethod def list_tuple(xdata, ydata): '''convert the x and y data for line plot''' return list(map(tuple, np.vstack((xdata, ydata)).T)) def on_touch_down(self, touch): print self.tl.U print self.tl.ts.n_e_x if self.collide_point(touch.x, touch.y): x0, y0 = self.graph._plot_area.pos # position of the lower-left x0 += self.x y0 += self.y # print x0, y0 # print touch.x, touch.y # print self.x, self.y gw, gh = self.graph._plot_area.size # graph size x = (touch.x - x0) / gw * self.graph.xmax y = (touch.y - y0) / gh * self.graph.ymax # to check is the controller is selected x0, x1 = self.controller.xrange y0, y1 = self.controller.yrange if (x >= x0) * (x <= x1) * (y >= y0) * (y <= y1): self.selected = True def on_touch_up(self, touch): self.selected = False def on_touch_move(self, touch): if self.selected: if self.collide_point(touch.x, touch.y): # position of the lower-left x0, y0 = self.graph._plot_area.pos gw, gh = self.graph._plot_area.size # graph size x = (touch.x - x0 - self.x) / gw * self.graph.xmax # make sure the controller doesn't enter the matrix x = max(x, 53.) x = min(x, 93.) if abs(x - self.x_current) >= 1: d_u = (x - self.x_current) * self.max_displacement / 40. self.tl.get_p(d_u) self.x_current = x # print self.tl.U_record[-1] # print self.tl.F_record[-1] self.f_u_line.points.append( (self.tl.U_record[-1], self.tl.F_record[-1])) self.eps_sig_line.points.append( (self.tl.eps_record[-1], self.tl.sig_record[-1])) U = np.reshape(self.tl.U, (-1, 2)).T self.matrix_disp_line.points = self.list_tuple( self.x_coord, U[0]) self.reinf_disp_line.points = self.list_tuple( self.x_coord, U[1]) self.slip_line.points = self.list_tuple( self.x_coord, U[1] - U[0]) shear_flow = self.tl.sig[:, :, 1].flatten() self.shear_flow_line.points = self.list_tuple( self.x_ip_coord, shear_flow) self.controller.xrange = [x - 3., x + 3.] self.reinf.xrange = [ min(10 + self.tl.U[1] * 40. / self.max_displacement, 30.), x - 3.]
from math import sin from kivy.garden.graph import Graph, MeshLinePlot 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=100, ymin=-1, ymax=1) plot = MeshLinePlot(color=[1, 0, 0, 1]) plot.points = [(x, sin(x / 10.)) for x in range(0, 101)] graph.add_plot(plot)