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):
# 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)
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 __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, 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 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 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 __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 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
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
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 __init__(self, t=[], I=[]):
"""
Paramètres
----------
t : list
Tableau de valeurs de temps.
I : list
Tableau de valeurs d'intensité.
"""
super(CottrellGraph, self).__init__(t, I)
graph_theme = {
'label_options': {
'color': [0, 0, 0, 1], # color of tick labels and titles
'bold': False
},
'background_color': [1, 1, 1, 1], # back ground color of canvas
'tick_color': [0, 0, 0, 1], # ticks and grid
'border_color': [0, 0, 0, 1]
} # border drawn around each graph
self.graph = Graph(title='Courbes de Cottrell',
xlabel='Temps (s)',
ylabel='Intensité (A)',
x_ticks_minor=5,
x_ticks_major=5,
y_ticks_major=0.2,
y_ticks_minor=4,
y_grid_label=self.ticks_labels,
x_grid_label=self.ticks_labels,
padding=5,
x_grid=False,
y_grid=False,
xmin=float(self.tleft),
xmax=float(self.tright),
ymin=float(self.Ibottom),
ymax=float(self.Itop),
legend=self.legend,
precision="%#.4g",
**graph_theme)
self.thplot = SmoothLinePlot(color=[0, 0, 1, 1])
self.thplot.label = "Théorique"
self.expplot = SmoothLinePlot(color=[1, 0, 0, 1])
self.expplot.label = "Expérimentale"
self.bind(legend=self.graph.setter('legend'))
self.bind(ticks_labels=self.graph.setter('y_grid_label'))
self.bind(ticks_labels=self.graph.setter('x_grid_label'))
self._trigger = Clock.create_trigger(self.update_ticks)
self.graph.bind(size=self._trigger)
self.graph._plot_area.bind(pos=self._trigger)
def 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
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)
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 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)
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 PsiScreen(Screen):
graph = Graph(xlabel=' ',
ylabel='',
x_ticks_minor=5,
x_ticks_major=0,
y_ticks_major=10,
y_ticks_minor=2,
y_grid_label=True,
x_grid_label=False,
padding=5,
x_grid=True,
y_grid=True,
xmin=-0,
xmax=50,
ymin=0,
ymax=100,
label_options={
'color': [0, 1, 1, 1],
'bold': False
},
border_color=[0, 1, 1, .1],
tick_color=[1, 1, 1, 1])
plot = LinePlot(color=[1, 0, 0, 1], line_width=1.5)
plot.points = [(0, 0)]
graph.add_plot(plot)
clock = Clock
def __init__(self, *args, **kwargs):
super(PsiScreen, self).__init__(*args, **kwargs)
self.ids["flt"].add_widget(self.graph)
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 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 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 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 __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 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 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 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 __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 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 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 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 __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 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 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 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
def __init__(self, n=3, xmin=0, xmax=10, ymin=-1, ymax=1, xlabel='Time'):
"""
n: number of graphs
xmin: minimum x
xmax: maximum x
ymin: minimum y
ymax: maximum y
xlabel: label for x axis (time of freq)
"""
super(Grapher, self).__init__(orientation='vertical')
self.graph = []
self.plots = []
if xlabel == 'Time':
self.plots.append(MeshLinePlot(color=[1, 0, 0, 1]))
self.plots.append(MeshLinePlot(color=[0, 1, 0, 1]))
self.plots.append(MeshLinePlot(color=[0, 0, 1, 1]))
else:
self.plots.append(MeshStemPlot(color=[1, 0, 0, 1]))
self.plots.append(MeshStemPlot(color=[0, 1, 0, 1]))
self.plots.append(MeshStemPlot(color=[0, 0, 1, 1]))
self.reset_plots()
for i in range(n):
self.graph.append(
Graph(xlabel=xlabel,
ylabel='Amp',
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=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax))
self.graph[i].add_plot(self.plots[i])
self.add_widget(self.graph[i])
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 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 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.]
class PowerMeterControl(TabbedPanel):
fpower = StringProperty('0.0')
power = NumericProperty(0.0)
max_power = NumericProperty(0.0)
voltage = NumericProperty(0)
tick_color = ListProperty([0, 1, 0, 1])
wavelength = BoundedNumericProperty(780.0,
min=340.0,
max=1180,
errorhandler=lambda x: 1180
if x > 1180 else 340)
connected = BooleanProperty(False)
logo = 'CQTtools_inverted.png'
graph = Graph()
plot = ObjectProperty(None)
powermeter = None
pm_range = 4
iteration = 0
dt = 0.25
def update(self, dt):
#adding by ChiHuan in v1.0. Averaging the reading.
v = []
average_v = 0
for i in range(0, 50):
v.append(float(self.powermeter.get_voltage()))
average_v = np.mean(v)
#self.voltage = float(self.powermeter.get_voltage())
self.voltage = float(average_v)
self.power = self.amp2power(self.voltage, self.wavelength,
int(self.pm_range))
self.fpower = self.formated_power() #
#self.power_max()
self.plot.points.append((self.iteration * dt, self.power * 1000))
#print self.plot.points
self.iteration += 1 * dt
if self.iteration > 150:
self.iteration = 0
self.plot.points = []
self.ids.graph1.remove_plot(self.plot)
def update_range(self, value):
self.pm_range = value
if self.connected == True:
self.pm_range = value
self.powermeter.set_range(int(self.pm_range))
print self.pm_range
return self.pm_range
def connect_to_powermeter(self, connection):
if not self.connected:
if platform == 'android': #to get access to serial port on android
os.system(
"su -c chmod 777 " + connection
) #has to run as child otherwise will not work with all su binarys
self.data = self._read_cal_file()
self.powermeter = pm.pmcommunication(connection)
Clock.schedule_interval(self.update, self.dt)
self.connected = True
self.update_range(self.pm_range)
plot = MeshLinePlot(color=[0, 1, 0, 1])
self.ids.graph1.add_plot(plot)
self.plot = plot
return self.powermeter
def serial_ports_android(self):
#Lists serial ports
ports = glob.glob('/dev/ttyACM*')
return ports
"""this section of the code deals with converting between the voltage value and the
optical power at the wavelength of interest"""
resistors = [1e6, 110e3, 10e3, 1e3,
20] #sense resistors adjust to what is on the board
file_name = 's5106_interpolated.cal' #detector calibration file
def _read_cal_file(self): # read in calibration file for sensor
f = open(self.file_name, 'r')
x = json.load(f)
f.close()
return x
def volt2amp(self, voltage, range_number):
self.amp = voltage / self.resistors[range_number]
return self.amp
def amp2power(self, voltage, wavelength, range_number):
amp = self.volt2amp(voltage, range_number - 1)
xdata = self.data[0]
ydata = self.data[1]
i = xdata.index(int(wavelength))
responsivity = ydata[i]
power = amp / float(responsivity)
return power
def formated_power(self):
power = self.amp2power(self.voltage, self.wavelength,
int(self.pm_range))
fpower = power * 1000
if 1 < fpower < 500:
fpower = round(fpower, 2)
out = str(fpower) + 'mW'
elif 0.001 < fpower < 1:
fpower = round(fpower * 1000, 2)
out = str(fpower) + 'uW'
elif 10e-6 < fpower < 0.001:
fpower = round(fpower * 1e6, 2)
out = str(fpower) + 'nW'
elif fpower < 10e-6:
out = 'Low'
else:
out = 'High'
return out
def power_max(self):
if self.max_power < self.power:
self.max_power = self.power
return self.max_power
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'
)
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(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
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
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
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)
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)
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 __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 Performance(StackLayout):
"""
This class contains the graphing application for the Kivy Dashboard
Application. It accepts a buffer string from a socket connection
established elsewhere in the software, then parses the data to be
inserted into a graph"""
graph = Graph(xlabel='Time', ylabel='', x_ticks_minor=5,
x_ticks_major=100, y_ticks_major=12,
y_grid_label=True, x_grid_label=True, padding=5,
x_grid=True, y_grid=True, xmin=-0, xmax=300, ymin=0, ymax=120, size_hint=(1,.9))
## creates graph object to be accessed by updateUI function
plot1 = MeshLinePlot(color=[1, 0, 0, 1])
plot2 = MeshLinePlot(color=[0, 1, 0, 1])
plot3 = MeshLinePlot(color=[0, 0, 1, 1])
last_data = '0,0,0,0'
## creates the initial plot objects for the garden.graph function
## with defining color
RPMbtn = ToggleButton(text='RPM', size_hint=(.33,.1))
ENGbtn = ToggleButton(text='Engine Load', size_hint=(.33,.1))
COTbtn = ToggleButton(text='Coolant Temp', size_hint=(.33,.1))
RPMstate = 0
ENGstate = 0
COTstate = 0
RPMlist = []
while(len(RPMlist)<300):
RPMlist.append(0)
ENGlist = []
while(len(ENGlist)<300):
ENGlist.append(0)
COTlist = []
while(len(COTlist)<300):
COTlist.append(0)
## Creates three lists, of length 300, all initialized to zero
## The graph will build from this list, and if it is not initialized to
## zero beforehand, it will get an indexing error
def __init__(self, **kwargs):
"""Creates the layout and widget tree for performance class"""
super(Performance, self).__init__(**kwargs)
self.add_widget(self.RPMbtn)
self.add_widget(self.ENGbtn)
self.add_widget(self.COTbtn)
self.add_widget(self.graph)
self.RPMbtn.bind(on_press = self.RPMplot)
self.ENGbtn.bind(on_press = self.ENGplot)
self.COTbtn.bind(on_press = self.COTplot)
Clock.schedule_interval(self.updateUI, 1.0/10.0)
## pings the updateUI function ten times a second, giving
## the graph a framerate of 10fps
def RPMplot(self, RPMbtn):
"""sets the state for the RPM button widget"""
if (self.RPMstate == 0):
self.RPMstate = 1
else:
self.RPMstate = 0
def ENGplot(self, ENGbtn):
"""sets the state for the Engine Load button widget"""
if (self.ENGstate == 0):
self.ENGstate = 1
else:
self.ENGstate = 0
def COTplot(self, COTbtn):
"""sets the state for the Coolant Temp button widget"""
if (self.COTstate == 0):
self.COTstate = 1
else:
self.COTstate = 0
def updateUI(self, dt):
"""Updates the parameters of the graph.
This function will remove redundant plots on the graph
then receive new data from bluetooth socket.
The data is broken up and placed on the graph
depending on the state of the button widgets
"""
try:
self.graph.remove_plot(plot1)
except:
pass
try:
self.graph.remove_plot(plot2)
except:
pass
try:
self.graph.remove_plot(plot3)
except:
pass
## tries to remove the previously added plots to the graph
## this prevents ghosting on the graph itself
# try:
# data = client_sock.recv(1024)
# if (len(data) < 1):
# data = self.last_data
# else:
# print data
# self.last_data = data
## Receive data as a string into 'data'. If the
## socket produces no information, as the vehicle will
## typically vary on how long between data is sent
## the data will either get '0,0,0,0' indicating no data
## has been sent yet, or it will use the last good data received
# except IOError, NameError:
# data = last_data
# if (client_sock == False):
# print "Socket Connection Lost"
# values = data.split(',')
## data is split into
self.RPMlist.insert(0, random.randint(60,80))
if(len(self.RPMlist)>300):
self.RPMlist = self.RPMlist[:300]
self.ENGlist.insert(0, random.randint(20,40))
if(len(self.ENGlist)>300):
self.ENGlist = self.ENGlist[:300]
self.COTlist.insert(0, random.randint(1,30))
if(len(self.COTlist)>300):
self.COTlist = self.COTlist[:300]
# Used for testing random numbers in the graph
# self.RPMlist.insert(0, int(values[1])/100)
# if(len(self.RPMlist)>300):
# self.RPMlist = self.RPMlist[:300]
# self.ENGlist.insert(0, int(values[2]))
# if(len(self.ENGlist)>300):
# self.ENGlist = self.ENGlist[:300]
# self.COTlist.insert(0, int(values[3]))
# if(len(self.COTlist)>300):
# self.COTlist = self.COTlist[:300]
## The values (data) are inserted into their respective
## performance metric lists
self.RPMbtn.text = str('RPM: ' + str(self.RPMlist[0]))
self.ENGbtn.text = str('Engine Load: ' + str(self.ENGlist[0]))
self.COTbtn.text = str('Coolant Temp: ' + str(self.COTlist[0]))
## Used to place random numbers in graph for testing
# self.RPMbtn.text = str('RPM: ' + values[1])
# self.ENGbtn.text = str('Engine Load: ' + values[2])
# self.COTbtn.text = str('Coolant Temp: ' + values[3])
## Updates the buttons on screen to the correct values
self.RPMlist.reverse()
self.ENGlist.reverse()
self.COTlist.reverse()
## Reverses each list so that the graph is displayed as scrolling from
## the right, rather than the left
if(self.RPMstate == 1):
self.plot1.points = ((x, self.RPMlist[x]) for x in xrange(0,300))
self.graph.add_plot(self.plot1)
if(self.ENGstate == 1):
self.plot2.points = ((x, self.ENGlist[x]) for x in xrange(0,300))
self.graph.add_plot(self.plot2)
if(self.COTstate == 1):
self.plot3.points = ((x, self.COTlist[x]) for x in xrange(0,300))
self.graph.add_plot(self.plot3)
## The App checks the state of the buttons, and updates the graph
## if the buttons are toggled
self.RPMlist.reverse()
self.ENGlist.reverse()
self.COTlist.reverse()
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 "================="
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)
class Chart(MDBoxLayout):
volume_graph = Graph(xlabel='time',
ylabel='volume',
x_ticks_minor=1,
x_ticks_major=5,
y_ticks_major=1,
y_grid_label=True,
x_grid_label=True,
padding=5,
x_grid=True,
y_grid=True,
xmin=0,
xmax=50,
ymin=-1,
ymax=1)
pressure_graph = Graph(xlabel='time',
ylabel='pressure',
x_ticks_minor=1,
x_ticks_major=5,
y_ticks_major=1,
y_grid_label=True,
x_grid_label=True,
padding=5,
x_grid=True,
y_grid=True,
xmin=0,
xmax=50,
ymin=-1,
ymax=1)
flow_graph = Graph(xlabel='time',
ylabel='flow',
x_ticks_minor=1,
x_ticks_major=5,
y_ticks_major=1,
y_grid_label=True,
x_grid_label=True,
padding=5,
x_grid=True,
y_grid=True,
xmin=0,
xmax=50,
ymin=-1,
ymax=1)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.orientation = 'vertical'
self.plot_pressure = LinePlot(color=[1, 0, 0, 1], line_width=2)
self.plot_flow = LinePlot(color=[1, 0, 0, 1], line_width=2)
self.plot_volume = LinePlot(color=[1, 0, 0, 1], line_width=2)
self.data = {'time': [], 'pressure': [], 'flow': [], 'volume': []}
threading.Thread(target=self.generate_data, daemon=True).start()
self.start()
def start(self):
self.pressure_graph.add_plot(self.plot_pressure)
self.flow_graph.add_plot(self.plot_flow)
self.volume_graph.add_plot(self.plot_volume)
self.add_widget(self.pressure_graph)
self.add_widget(self.flow_graph)
self.add_widget(self.volume_graph)
Clock.schedule_interval(self.get_value, 0.05)
def stop(self):
Clock.unschedule(self.get_value)
def get_value(self, dt):
self.update_axis()
self.plot_pressure.points = [(x, self.data['pressure'][i])
for i, x in enumerate(self.data['time'])]
self.plot_flow.points = [(x, self.data['flow'][i])
for i, x in enumerate(self.data['time'])]
self.plot_volume.points = [(x, self.data['volume'][i])
for i, x in enumerate(self.data['time'])]
def update_axis(self, *args):
if len(self.data['time']) == NUMBEROFPOINTS:
self.pressure_graph.xmin = self.data['time'][0]
self.pressure_graph.xmax = self.data['time'][-1]
self.flow_graph.xmin = self.data['time'][0]
self.flow_graph.xmax = self.data['time'][-1]
self.volume_graph.xmin = self.data['time'][0]
self.volume_graph.xmax = self.data['time'][-1]
def generate_data(self):
x = -10
while True:
current_pressure_value = math.cos(x)
current_flow_value = math.sin(x)
current_volume_value = -math.cos(x)
if len(self.data['time']) == NUMBEROFPOINTS:
for data in self.data: # deleting the first elements to keep the number of elements constant
del self.data[data][0]
self.data['pressure'].append(current_pressure_value)
self.data['flow'].append(current_flow_value)
self.data['volume'].append(current_volume_value)
self.data['time'].append(x)
x += 1 # Incrementing the horizontal axis or the time axis
time.sleep(.1)
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)
class Chart(MDBoxLayout):
volume_graph = ObjectProperty(defaultvalue=Graph(xlabel='Time (s)',
ylabel='Volume (ml)',
x_ticks_minor=1,
x_ticks_major=1,
y_ticks_major=1,
y_grid_label=True,
x_grid_label=True,
padding=5,
xmin=0,
xmax=50,
ymin=VOLUME_Y_LIMITS[0],
ymax=VOLUME_Y_LIMITS[1]))
pressure_graph = ObjectProperty(
defaultvalue=Graph(xlabel='Time (s)',
ylabel='Pressure (cm H20)',
x_ticks_minor=1,
x_ticks_major=1,
y_ticks_major=1,
y_grid_label=True,
x_grid_label=True,
padding=5,
xmin=0,
xmax=50,
ymin=PRESSURE_Y_LIMITS[0],
ymax=PRESSURE_Y_LIMITS[1]))
flow_graph = ObjectProperty(defaultvalue=Graph(xlabel='Time (s)',
ylabel='Flow (l/min)',
x_ticks_minor=1,
x_ticks_major=1,
y_ticks_major=1,
y_grid_label=True,
x_grid_label=True,
padding=5,
xmin=0,
xmax=50,
ymin=FLOW_Y_LIMITS[0],
ymax=FLOW_Y_LIMITS[1]))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.orientation = 'vertical'
self.plot_pressure = LinePlot(color=[1, 0, 0, 1], line_width=2)
self.plot_flow = LinePlot(color=[1, 0, 0, 1], line_width=2)
self.plot_volume = LinePlot(color=[1, 0, 0, 1], line_width=2)
self.data = {'time': [], 'pressure': [], 'flow': [], 'volume': []}
threading.Thread(target=self.generate_data, daemon=True).start()
self.start()
def start(self):
self.pressure_graph.add_plot(self.plot_pressure)
self.flow_graph.add_plot(self.plot_flow)
self.volume_graph.add_plot(self.plot_volume)
self.add_widget(self.pressure_graph)
self.add_widget(self.flow_graph)
self.add_widget(self.volume_graph)
# Clock.schedule_interval(self.get_value, 0.05)
threading.Thread(target=self.get_value, args=(0.05, ),
daemon=True).start()
def stop(self):
Clock.unschedule(self.get_value)
def get_value(self, delay=.05):
while True:
self.update_axis()
self.plot_pressure.points = [
(x, self.data['pressure'][i])
for i, x in enumerate(self.data['time'])
]
self.plot_flow.points = [(x, self.data['flow'][i])
for i, x in enumerate(self.data['time'])]
self.plot_volume.points = [(x, self.data['volume'][i])
for i, x in enumerate(self.data['time'])
]
# Make the program sleep before resuming the iteration
time.sleep(delay)
def update_axis(self, *args):
# Modifying the x-axis
if len(self.data['time']) == NUMBER_OF_POINTS:
self.pressure_graph.xmin = self.data['time'][0]
self.pressure_graph.xmax = self.data['time'][-1]
self.flow_graph.xmin = self.data['time'][0]
self.flow_graph.xmax = self.data['time'][-1]
self.volume_graph.xmin = self.data['time'][0]
self.volume_graph.xmax = self.data['time'][-1]
# Modifying the y-axis
if max(self.data['pressure']) >= PRESSURE_Y_LIMITS[1]:
self.pressure_graph.ymax = max(self.data['pressure']) + 1
if max(self.data['flow']) >= FLOW_Y_LIMITS[1]:
self.flow_graph.ymax = max(self.data['flow']) + 1
if max(self.data['volume']) >= VOLUME_Y_LIMITS[1]:
self.volume_graph.ymax = max(self.data['volume']) + 1
def generate_data(self):
x = -10
while True:
if ((x - (x % 10)) / 10) % 2 == 0:
current_pressure_value = self.triangular_wave(t=x,
period=2,
scale=1,
duty_cycle=.5)
current_flow_value = self.triangular_wave(t=x,
period=2,
scale=1,
duty_cycle=.2)
current_volume_value = self.triangular_wave(t=x,
period=2,
scale=4,
duty_cycle=.6)
else:
current_pressure_value = self.triangular_wave(t=x,
period=2,
scale=1,
duty_cycle=.5)
current_flow_value = self.triangular_wave(t=x,
period=2,
scale=2,
duty_cycle=.2)
current_volume_value = self.triangular_wave(t=x,
period=2,
scale=1,
duty_cycle=.6)
if len(self.data['time']) == NUMBER_OF_POINTS:
for data in self.data: # deleting the first elements to keep the number of elements constant
del self.data[data][0]
self.data['pressure'].append(current_pressure_value)
self.data['flow'].append(current_flow_value)
self.data['volume'].append(current_volume_value)
self.data['time'].append(x)
x += .2 # Incrementing the horizontal axis or the time axis
time.sleep(.1)
@staticmethod
def triangular_wave(t, period, scale=1, duty_cycle=.5):
actual_time = t % period
if actual_time <= duty_cycle * period:
return scale * actual_time
else:
return 0
