def setup(self, layout):
""" This method creates the graph that is displayed on the top half of
the user interface. Currently, the axes are completely hard-coded in
this method and cannot be changed on-the-fly. """
figure = Figure(facecolor=Display.background)
axes = figure.add_subplot(111)
# In order to create a line object, a dummy line needs to be plotted.
# This line will get replaced before the GUI is shown to the user.
pi = numpy.pi
x = y = self.abscissa
self.curve = axes.plot(x, y)[0]
self.canvas = FigureCanvasGTKAgg(figure)
# The tick labels are formatted using LaTeX. This makes it possible
# to use symbols like pi.
axes.set_xticks((-pi, 0, pi))
axes.set_xticklabels((r"-pi", "0", r"pi"))
axes.set_xlim(-pi - 0.25, pi + 0.25)
axes.set_yticks((0, 1))
axes.set_yticklabels(("0", "1"))
axes.set_ylim((-0.1, 1.1))
layout.pack_start(self.canvas)
def __init__(self,src,model,state):
self.src = src
self.model = model
self.__state = state
state.connect('selection-changed',self.update_spanner)
state.connect('selection-removed',self.remove_spanner)
xb = src.get_time_bounds()
yb = src.get_data_bounds()
figure = Figure(dpi=100)
self.plot = figure.add_subplot(111,xbound=xb,ybound=yb,autoscale_on=False)
self.plot.plot_date(src.get_time(True),src.get_data(True),'-')
if state.selection is None:
self.spanner = None
else:
vall,valr = state.selection
self.spanner = self.plot.axvspan(vall,valr,alpha=0.5)
self.ctx_spanners = dict()
FigureCanvas.__init__(self,figure)
self.mpl_connect('button_press_event',self.on_press)
self.mpl_connect('button_release_event',self.on_release)
self.mpl_connect('motion_notify_event',self.on_move)
model.connect('annotation-added',self.notice_annotation)
model.connect('annotation-removed',self.notice_annotation_removal)
model.connect('annotation-changed',self.notice_annotation_change)
for (id,color,boundl,boundr) in model.annotations():
self.notice_annotation(model,id,color,boundl,boundr)
def __init__(self,
data,
x,
y,
slice_idx,
cmap=P.cm.gray,
norm=None,
interpolation="bilinear",
extent=None):
self.norm = norm
self.cmap = cmap
self.interpolation = interpolation
self.slice_idx = slice_idx
# extent should be static, so set it and leave it alone
if not extent:
y, x = data.shape[-2:]
extent = [-x / 2., x / 2., -y / 2., y / 2.]
self.extent = extent
self.ylim = tuple(extent[2:])
self.xlim = tuple(extent[:2])
fig = P.Figure(figsize=P.figaspect(data), dpi=80)
ax = fig.add_subplot(111)
ax.yaxis.tick_right()
ax.title.set_y(1.05)
FigureCanvas.__init__(self, fig)
self.setData(data)
self._init_crosshairs(x, y)
class Plotter(gtk.VBox):
def __init__(self, xlabel, ylabel, width=500, height=500, dpi=75):
"""
:type xlabel: str
:type ylabel: str
:type width: int
:type height: int
:type dpi: int
"""
gtk.VBox.__init__(self)
figure = Figure(figsize=(width, height), dpi=dpi)
self.axes = figure.add_subplot(111, xlabel=xlabel, ylabel=ylabel)
""" :type: matplotlib.axes.Axes """
self.axes.hold(False)
self.canvas = FigureCanvas(figure)
#self.canvas.mpl_connect('button_press_event', self.klick)
nav = NavigationToolbar(self.canvas, self)
self.pack_start(nav, False, False)
self.pack_start(self.canvas)
def leeren(self):
self.axes.hold(False)
def plot(self, x, y, **args):
self.axes.plot(x, y, antialiased=True, **args)
self.axes.hold(True)
def draw(self):
self.canvas.draw()
"""def klick(self, evt):
def recreate_canvas(self, fig):
canvas = FigureCanvas(fig)
canvas.set_size_request(450, 200)
if self.canvas_frame.get_child():
self.canvas_frame.remove(self.canvas_frame.get_child())
self.canvas_frame.add(canvas)
canvas.show()
class plotWindow:
def __init__(self, title):
#title is the title of the window.
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#mod for win:
try:
self.window.set_icon_from_file(
os.path.join(ICON_PATH, "Shim-icon" + ICON_EXTENSION))
except:
pass
vbox = gtk.VBox(False)
self.window.add(vbox)
self.window.set_size_request(600, 400)
self.window.set_title(title)
self.fig = Figure(figsize=(4, 3), dpi=100)
self.ax = self.fig.add_subplot(111)
self.ax.set_position([0.2, 0.2, 0.7, 0.7])
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
vbox.pack_start(self.canvas, True, True, 0)
self.ax.set_xlabel("Shim dial value")
self.ax.set_ylabel("FWQM")
def updatePlot(self, xmin, xmax, ymin, ymax, xvals, yvals, name):
plotWin.ax.cla() # clear out what was there.
plotWin.ax.set_xlim([xmin, xmax])
plotWin.ax.set_ylim([ymin, ymax])
plotWin.ax.set_xlabel(name + " shim dial value")
plotWin.ax.set_ylabel("FWQM")
plotWin.ax.plot(xvals, yvals, 'bo')
self.canvas.draw_idle()
return False
def __init__(self):
print 'test'
self.win = gtk.Window()
#win.connect("destroy", lambda x: gtk.main_quit())
self.win.connect("delete-event", self.hideinsteadofdelete)
self.win.set_default_size(400,300)
self.win.set_title("Embedding in GTK")
f = Figure(figsize=(5,4), dpi=100)
a = f.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
a.plot(t,s)
sw = gtk.ScrolledWindow()
self.win.add (sw)
# A scrolled window border goes outside the scrollbars and viewport
sw.set_border_width (10)
# policy: ALWAYS, AUTOMATIC, NEVER
sw.set_policy (hscrollbar_policy=gtk.POLICY_AUTOMATIC,
vscrollbar_policy=gtk.POLICY_ALWAYS)
canvas = FigureCanvas(f) # a gtk.DrawingArea
canvas.set_size_request(800,600)
sw.add_with_viewport (canvas)
self.win.show_all()
gtk.main()
def __init__(self):
# Minimal gtk initialization
self.builder = gtk.Builder()
self.builder.add_from_file("roi_image.glade")
self.builder.connect_signals(self)
# Create a matplotlib figure for the image
self.imageFigure = Figure(figsize=(5,4), dpi=100)
self.imagePlot = self.imageFigure.add_subplot(111)
# Place the matplotlib figures into a container
self.imageCanvas = FigureCanvas(self.imageFigure) # a gtk.DrawingArea
self.builder.get_object('imageViewPort').add(self.imageCanvas)
# Create a matplotlib figure for the plot
self.plotFigure = Figure(figsize=(5,4), dpi=100)
self.plotPlot = self.plotFigure.add_subplot(111)
# Place the matplotlib figures into a container
self.plotCanvas = FigureCanvas(self.plotFigure) # a gtk.DrawingArea
self.builder.get_object('plotViewPort').add(self.plotCanvas)
self.builder.get_object('lowIndexSlider').set_range(0,2047)
self.builder.get_object('lowIndexSlider').set_value(0)
self.builder.get_object('highIndexSlider').set_range(0,2047)
self.builder.get_object('highIndexSlider').set_value(2047)
self.mCurrentLowLimit = 0
self.mCurrentHighLimit = 2047
class HelloMatplotlib:
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_size_request(400, 400)
self.window.set_border_width(10)
f = Figure(figsize=(5,4), dpi=100)
a = f.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
a.plot(t,s)
self.canvas = FigureCanvas(f)
self.canvas.show()
self.window.add(self.canvas)
self.window.show()
def delete_event(self, widget, event, data=None):
gtk.main_quit()
def destroy(self, widget, data=None):
gtk.main_quit()
def main(self):
gtk.main()
def __init__(self, x, y, title="Graph", parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except:
self.connect('destroy', lambda *w: self.destroy())
self.set_title(title)
self.set_default_size(800, 600)
self.set_border_width(2)
self.set_position(gtk.WIN_POS_CENTER)
box = gtk.VBox()
self.add(box)
fig = Fig(figsize=(5,4), dpi=100)
ax = fig.add_subplot(111)
ax.plot(x, y)
canvas = FigCan(fig)
canvas.mpl_connect('key_press_event', self.on_key_event)
box.pack_start(canvas)
toolbar = NavBar(canvas, self)
box.pack_start(toolbar, False, False)
self.show_all()
del box, fig, ax, canvas, toolbar
def __init__(self):
self._gladefile = "neuronview.glade"
self._builder = gtk.Builder()
self._builder.add_from_file(self._gladefile)
self._builder.connect_signals(self)
self._win = self._builder.get_object("mainwindow")
self._win.resize(900, 700)
box = self._builder.get_object("box5")
self._stimulatordictview = DictView()
self._builder.get_object("scrolledwindow2").add(self._stimulatordictview)
box = self._builder.get_object("box4")
self._neurondictview = DictView()
self._builder.get_object("scrolledwindow3").add(self._neurondictview)
self.populate_comboboxes()
self._figure = Figure(figsize=(5,4), dpi=100)
canvas = FigureCanvas(self._figure)
canvas.set_size_request(200, 250)
canvas.show()
box = self._builder.get_object("box3")
bg_style = box.get_style().bg[gtk.STATE_NORMAL]
gtk_color = (bg_style.red_float, bg_style.green_float, bg_style.blue_float)
self._figure.set_facecolor(gtk_color)
box.pack_start(canvas)
self._win.show()
gtk.main()
def visualize(*args, **kwargs):
"""
Method that does all magic to to with GTK.
All arguments passed to grapher.matplot.Graph
"""
logger.debug('Spawning a GTK window')
win = gtk.Window()
win.connect('destroy', lambda x: gtk.main_quit())
win.set_default_size(800,500)
win.set_title('BounceItBaby visualizer')
sw = gtk.ScrolledWindow()
win.add(sw)
# TODO: allow arrow/hjkl buttons to scroll
sw.set_policy(hscrollbar_policy=gtk.POLICY_ALWAYS,
vscrollbar_policy=gtk.POLICY_AUTOMATIC)
logger.debug('Building the Figure from data')
figure = Graph(*args, **kwargs)
canvas = FigureCanvas(figure)
# If time scale is 20 times longer than number of actors, make it 20 times
# wider than it is tall.
canvas.set_size_request(int(400 / figure.axes[0].get_data_ratio()), 400)
sw.add_with_viewport(canvas)
logger.debug('Displaying GTK window!')
win.show_all()
gtk.main()
class Display:
""" This class is responsible for rendering the graph in the upper portion
of the window. The data in the graph is taken from a Simulation object,
which is accessed through the main Interface object. """
# This is a color I chose to perfectly match the background of the rest of
# the interface. It might only work on my computer.
# Malingo: Yes, it only works on your computer. It depends on what gtk
# theme the user has chosen.
background = "#edecea"
def __init__(self, main):
self.main = main
pi = numpy.pi
self.abscissa = numpy.arange(-pi - .25, pi + 0.25, 0.01)
self.curve = None
self.canvas = None
def setup(self, layout):
""" This method creates the graph that is displayed on the top half of
the user interface. Currently, the axes are completely hard-coded in
this method and cannot be changed on-the-fly. """
figure = Figure(facecolor=Display.background)
axes = figure.add_subplot(111)
# In order to create a line object, a dummy line needs to be plotted.
# This line will get replaced before the GUI is shown to the user.
pi = numpy.pi
x = y = self.abscissa
self.curve = axes.plot(x, y)[0]
self.canvas = FigureCanvasGTKAgg(figure)
# The tick labels are formatted using LaTeX. This makes it possible
# to use symbols like pi.
axes.set_xticks((-pi, 0, pi))
axes.set_xticklabels((r"-\pi", "0", r"\pi"))
axes.set_xlim(-pi - 0.25, pi + 0.25)
axes.set_yticks((0, 1))
axes.set_yticklabels(("0", "1"))
axes.set_ylim((-0.1, 1.1))
layout.pack_start(self.canvas)
def update(self):
""" This method updates the graph using the new ordinate values
returned by the simulation. """
main = self.main
simulation = main.simulation
ordinate = simulation.plot(self.abscissa)
self.curve.set_ydata(ordinate)
self.canvas.draw()
def __init__(self,t_from,t_to): self.figure = Figure(figsize=(10,2), dpi=80) self.t_from = t_from self.t_to = t_to self.t_diff = math.fabs(t_from - t_to) self.axis = None FigureCanvas.__init__(self,self.figure)
class FigureWidget(gtk.ScrolledWindow):
def __init__(self, figure):
super(FigureWidget, self).__init__()
self.set_border_width(10)
self.set_policy(hscrollbar_policy=gtk.POLICY_AUTOMATIC,
vscrollbar_policy=gtk.POLICY_ALWAYS)
self.canvas = FigureCanvas(figure)
self.canvas.set_size_request(500, 100)
self.add_with_viewport(self.canvas)
def __init__(self, t_from, t_to):
self.figure = Figure(figsize=(10, 2), dpi=80)
self.t_from = t_from
self.t_to = t_to
self.t_diff = math.fabs(t_from - t_to)
self.axis = None
FigureCanvas.__init__(self, self.figure)
class Display:
""" This class is responsible for rendering the graph in the upper portion
of the window. The data in the graph is taken from a Simulation object,
which is accessed through the main Interface object. """
# This is a color I chose to perfectly match the background of the rest of
# the interface. It might only work on my computer.
background = "#edecea"
def __init__(self, main):
self.main = main
pi = numpy.pi
self.abscissa = numpy.arange(-pi - .25, pi + 0.25, 0.01)
self.curve = None
self.canvas = None
def setup(self, layout):
""" This method creates the graph that is displayed on the top half of
the user interface. Currently, the axes are completely hard-coded in
this method and cannot be changed on-the-fly. """
figure = Figure(facecolor=Display.background)
axes = figure.add_subplot(111)
# In order to create a line object, a dummy line needs to be plotted.
# This line will get replaced before the GUI is shown to the user.
pi = numpy.pi
x = y = self.abscissa
self.curve = axes.plot(x, y)[0]
self.canvas = FigureCanvasGTKAgg(figure)
# The tick labels are formatted using LaTeX. This makes it possible
# to use symbols like pi.
axes.set_xticks((-pi, 0, pi))
axes.set_xticklabels((r"-pi", "0", r"pi"))
axes.set_xlim(-pi - 0.25, pi + 0.25)
axes.set_yticks((0, 1))
axes.set_yticklabels(("0", "1"))
axes.set_ylim((-0.1, 1.1))
layout.pack_start(self.canvas)
def update(self):
""" This method updates the graph using the new ordinate values
returned by the simulation. """
main = self.main
simulation = main.simulation
ordinate = simulation.plot(self.abscissa)
self.curve.set_ydata(ordinate)
self.canvas.draw()
def __init__(self, win, size, show_labels=True):
fig = Figure(figsize=(size, size))
canvas = FigureCanvas(fig) # a gtk.DrawingArea
canvas.set_size_request(500, 500)
toolbar = NavigationToolbar(canvas, win)
self.vbox = gtk.VBox()
self.vbox.pack_start(canvas)
self.vbox.pack_start(toolbar, False, False)
self.fig = fig
self.show_labels = show_labels
self.eventfiles = {}
def __init__(self):
gladefile = "paViewerGUI.glade"
self.windowname = "MainWindow"
self.wTree = gtk.glade.XML(gladefile, self.windowname)
dic = {
"on_MainWindow_destroy": gtk.main_quit,
"on_ButtonQuit_clicked": gtk.main_quit,
"on_ButtonOpen_clicked": self.Open,
"on_ButtonPlane_clicked": self.ChangePlane,
"on_change_Current": self.ChangeCurrent,
"on_ButtonSave_clicked": self.SaveFigure
}
self.wTree.signal_autoconnect(dic)
self.window = self.wTree.get_widget(self.windowname)
self.XmaxIndicator = self.wTree.get_widget("LabelXMax")
self.YmaxIndicator = self.wTree.get_widget("LabelYMax")
self.ZmaxIndicator = self.wTree.get_widget("LabelZMax")
self.XScaler = self.wTree.get_widget("ScaleX")
self.YScaler = self.wTree.get_widget("ScaleY")
self.ZScaler = self.wTree.get_widget("ScaleZ")
self.XText = self.wTree.get_widget("EntryX")
self.YText = self.wTree.get_widget("EntryY")
self.ZText = self.wTree.get_widget("EntryZ")
self.PlaneSwitcher = self.wTree.get_widget("ButtonPlane")
self.PlaneIndicator = self.wTree.get_widget("LabelPlane")
self.window.show()
self.OpenFileName = os.getcwd()
self.plane = "xy"
self.lock = 0
self.draw_lock = 0
self.pa = None
self.TitleOfPlots = []
self.ax = []
self.figure = Figure(figsize=(6, 6), dpi=72)
self.figure.subplots_adjust(left=0.05,
right=1.0,
bottom=0.07,
top=0.95,
wspace=0.2,
hspace=0.1)
self.canvas = FigureCanvasGTKAgg(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.view = self.wTree.get_widget("ViewFrame")
self.view.add(self.canvas)
def graficar(self, datos, datos1, titulo):
datos = datos # valores del tiempo de espera.
datos1 = datos1 # valores de tiempo de cpu, tiempo de llegada y numeró de procesos.
titulo = titulo
x1 = []
y1 = []
y2 = []
n = len(datos)
for i in xrange(n):
x1.append(datos1[i][0]) #Numero de proceso
y1.append(datos[i][1]) #Tiempo de espera
y2.append(datos1[i][1]) #tiempo de uso del cpu
self.win = gtk.Window()
self.win.set_default_size(600,480)
self.win.set_position(gtk.WIN_POS_CENTER)
self.win.set_title(titulo)
f = Figure(figsize=(5,4), dpi=100)
a = f.add_subplot(111)
a.plot(x1, y1, color='blue', label='(Procesos, Tiempo de espera)')
a.legend(loc = 2)
a.set_title(titulo, color='red', size=14)
a.set_xlabel(u'Número de procesos', color='red', size=14)
a.set_ylabel('Tiempo de espera ', color='red', size=14)
"""
# gráfica procesos vs tiempo de cpu
#g = Figure(figsize=(5,4), dpi=100)
b = f.add_subplot(111)
b.plot(x1, y2, color='red', label='(Procesos, Tiempo de CPU)')
b.set_xlabel(u'Número de procesos', color='red', size=14)
b.set_ylabel('Tiempo de CPU ', color='red', size=14)
"""
vbox = gtk.VBox(False, 5)
canvas = FigureCanvas(f)
canvas.show()
#canvas1 = FigureCanvas(g)
#canvas1.show()
vbox.pack_start(canvas, True, True, 0)
#vbox.pack_start(canvas1, True, True, 0)
cerrar = gtk.Button(stock=gtk.STOCK_CLOSE)
cerrar.connect("activate", self.close)
vbox.pack_start(cerrar, False, False, 0)
self.win.add(vbox)
self.win.show_all()
class PowerGraph(gtk.Window):
def __init__(self, powers, step=0.5, title="Power Graph", parent=None):
x = []
y = []
for power, next_power in itertools.izip(powers, powers[1:]):
u = float(power[0])
u1 = float(next_power[0])
while u < u1:
x.append(u)
y.append(float(eval(power[1])))
u += step*(u1-u)
x.append(float(powers[-1][0]))
y.append(float(eval(powers[-1][1])))
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: self.destroy())
if parent is not None:
self.set_parent(parent)
self.set_title(title)
self.set_destroy_with_parent(True)
self.set_default_size(600, 400)
vbox = gtk.VBox()
self.add(vbox)
figure = Figure(figsize=(5,4), dpi=100)
subplot = figure.add_subplot(111)
subplot.plot(x, y)
subplot.set_title("Power Graph")
subplot.set_xlabel("Speed (u) [m/s]")
subplot.set_ylabel("Power [kW]")
subplot.grid(True)
self.canvas = FigureCanvas(figure)
self.canvas.mpl_connect('key_press_event', self.on_key_event)
vbox.pack_start(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self)
vbox.pack_start(self.toolbar, False, False)
self.show_all()
def on_key_event(self, event):
key_press_handler(event, self.canvas, self.toolbar)
def create_figure(quotes):
f = Figure(figsize=(5, 4), dpi=100)
a = f.add_subplot(111)
canvas = FigureCanvas(f) # a gtk.DrawingArea
canvas.set_size_request(800, 300)
a.xaxis_date()
finance.candlestick(a, quotes, width=0.5)
return f
def create_figure(quotes): f = Figure(figsize=(5,4), dpi=100) a = f.add_subplot(111) canvas = FigureCanvas(f) # a gtk.DrawingArea canvas.set_size_request(800,300) a.xaxis_date() finance.candlestick(a, quotes, width=0.5) return f
class WidgetsWrapper:
def __init__(self):
self.widgets = gtk.glade.XML('test.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self['windowMain'].connect('destroy', lambda x: gtk.main_quit())
self['windowMain'].move(10,10)
self.figure = Figure(figsize=(8,6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
self.axis.plot(t,s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.canvas.set_size_request(600, 400)
def onselect(xmin, xmax):
print xmin, xmax
span = HorizontalSpanSelector(self.axis, onselect, useblit=False,
rectprops=dict(alpha=0.5, facecolor='red') )
self['vboxMain'].pack_start(self.canvas, True, True)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, True, True)
self['vboxMain'].reorder_child(self['buttonClickMe'],-1)
def __getitem__(self, key):
return self.widgets.get_widget(key)
def setup(self, layout):
""" This method creates the graph that is displayed on the top half of
the user interface. Currently, the axes are completely hard-coded in
this method and cannot be changed on-the-fly. """
figure = Figure(facecolor=Display.background)
axes = figure.add_subplot(111)
# In order to create a line object, a dummy line needs to be plotted.
# This line will get replaced before the GUI is shown to the user.
pi = numpy.pi
x = y = self.abscissa
self.curve = axes.plot(x, y)[0]
self.canvas = FigureCanvasGTKAgg(figure)
# The tick labels are formatted using LaTeX. This makes it possible
# to use symbols like pi.
axes.set_xticks((-pi, 0, pi))
axes.set_xticklabels((r"-\pi", "0", r"\pi"))
axes.set_xlim(-pi - 0.25, pi + 0.25)
axes.set_yticks((0, 1))
axes.set_yticklabels(("0", "1"))
axes.set_ylim((-0.1, 1.1))
layout.pack_start(self.canvas)
def __init__(self,networkVariables):
'''
'''
super(realTimeVisualisation,self).__init__()
self.set_size_request(640,690)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", gtk.main_quit)
self.fig = Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.canvas.set_size_request(640,690)
vbox = gtk.VBox(False,1)
alignIm = gtk.Alignment(0, 1 , 1, 0)
alignIm.add(self.canvas)
vbox.pack_start(alignIm)
self.add(vbox)
self.initNetworkVariables(networkVariables)
self.createGraph()
updateTime = 1 #len(self.quantitiesToPlot) ## if this time is to fast, it will show nothing
gobject.timeout_add(updateTime,self.updateGraph)
self.show_all()
def __init__(self, xs, ys):
self.xs=xs
self.ys=ys
self.win = gtk.Window()
self.win.connect("destroy", lambda x: gtk.main_quit())
self.win.set_default_size(800,600)
self.win.set_title("openSpectrometer")
self.vbox = gtk.VBox()
self.win.add(self.vbox)
self.fig = Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.ax = self.fig.add_subplot(111)
self.canvas.mpl_connect('pick_event', self.onpick)
self.vbox.pack_start(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self.win)
self.hbox = gtk.HBox()
self.button=gtk.Button('Select this point as lambda max')
self.button.connect("clicked", self.buttonClick)
self.hbox.pack_start(self.toolbar)
self.hbox.pack_start(self.button)
self.vbox.pack_start(self.hbox, False, False)
self.lastind = 0
self.text = self.ax.text(0.05, 0.95, 'Datapoint index selected: none',
transform=self.ax.transAxes, va='top')
def __init__(self):
self.win = gtk.Window()
#win.connect("destroy", lambda x: gtk.main_quit())
self.win.connect("delete-event", self.hideinsteadofdelete)
self.win.set_default_size(400,300)
self.win.set_title("Embedding in GTK")
vbox = gtk.VBox()
self.win.add(vbox)
self.f = Figure(figsize=(5,4), dpi=100)
sw = gtk.ScrolledWindow()
vbox.pack_start(sw)
#self.win.add (sw)
# A scrolled window border goes outside the scrollbars and viewport
sw.set_border_width (10)
# policy: ALWAYS, AUTOMATIC, NEVER
sw.set_policy (hscrollbar_policy=gtk.POLICY_AUTOMATIC,
vscrollbar_policy=gtk.POLICY_ALWAYS)
self.canvas = FigureCanvas(self.f) # a gtk.DrawingArea
#vbox.pack_start(canvas)
self.canvas.set_size_request(300,200)
sw.add_with_viewport (self.canvas)
manager = get_current_fig_manager()
# you can also access the window or vbox attributes this way
toolbar = manager.toolbar
#vbox.pack_start(canvas)
toolbar = NavigationToolbar(self.canvas, self.win)
vbox.pack_start(toolbar, False, False)
self.win.show_all()
def __createNewFigure(self):
#Setup for plotting
if self.__hasPlotNow:
self.__plotVBox.remove(self.__plotToolbar)
self.__plotVBox.remove(self.__plotCanvas)
del self.__plotToolbar
self.__plotCanvas.destroy()
del self.__plotFigure
self.__plotFigure = matplotlib.pyplot.figure()
self.__plotAxis = self.__plotFigure.add_subplot(1,1,1)
self.__plotCanvas = FigureCanvasGTKAgg(self.__plotFigure)
self.__plotCanvas.show()
self.__plotVBox.pack_start(self.__plotCanvas, expand=True)
self.__plotToolbar = NavigationToolbar2GTKAgg(self.__plotCanvas, window=self.getBaseWindow().get_parent_window())
self.__plotVBox.pack_start(self.__plotToolbar, expand=False)
self.__hasPlotNow = True
#Plot the data
self.__plotAxis.set_xlabel(self.anaInstance.xVariable)
self.__plotAxis.set_ylabel(self.anaInstance.yVariable)
self.__plotAxis.set_title("Filter: " + self.anaInstance.fVariable + " = " + str(self.anaInstance.fEquals))
matplotlib.pyplot.plot(self.anaInstance.xArray, self.anaInstance.yArray, "*")
if self.anaInstance.targetValue != None:
matplotlib.pyplot.axhline(self.anaInstance.targetValue, color="r", linestyle="--")
(xmin,xmax,ymin,ymax) = self.__plotAxis.axis()
dx = xmax-xmin; dy = ymax-ymin;
self.__plotAxis.axis([xmin-dx*0.05, xmax+dx*0.05, ymin-dy*0.05, ymax+dy*0.05])
def __init__(self, dpi=100, x_pixel_size=500, y_pixel_size=400):
gtk.HBox.__init__(self)
# If the class is being reinitialized, we need to remove the old plot
[self.remove(child) for child in self.get_children()]
self.vbox = gtk.VBox()
self.pack_start(self.vbox)
# this is bad with labels, I have to figure out why
self.connect('size_allocate', self._full_update)
self.fig = Figure(figsize=(float(x_pixel_size)/dpi,
float(y_pixel_size)/dpi),
dpi=dpi)
self.fig.set_facecolor('white')
self.canvas = FigureCanvasGTKAgg(self.fig)
self.ax = self.fig.add_subplot(111)
self.vbox.pack_end(self.canvas)
self.canvas.connect('button_press_event', self._on_mouse_click)
self.first_update = True
self.settings = {}
self.n_lines = None
#self.line_styles = None
#self.line_colors = None
self.lines = None
self.saved_window_size = None
self.background = None
self.auto_x_scale = False
self.auto_y_scale = False
def __init__(self):
Widget.__init__(self)
path = os.environ['GRIMA_ETC']
name = 'grima-subplot-widget'
self.loadui(path, name)
self.loaddb(path, name)
self.__figure = Figure()
self.__canvas = FigureCanvas(self.__figure)
self.__toolbar = NavigationToolbar(self.__canvas, None)
self.__canvas.show()
self.figure = self.__figure
widget = gtk.VBox()
widget.show()
widget.pack_start(self.__canvas)
widget.pack_start(self.__toolbar, False, False)
container = self.builder.get_object('container')
container.add(widget)
self.__filename = None
self.__plotables = []
self.__chooser = SaveAs()
self.__chooser.deletable = False
self.__chooser.embedded = True
self.__chooser.callback = self.__save
def openCameraConfig(self):
try:
self.builder.get_object("ccimgbox").remove(self.canvascc)
except:
pass
ret,img = self.cap.read()
try:
img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#cv2.imshow("newtest",img)
except:
img=np.zeros((100,100))
self.builder.get_object("resx").set_text(str(img.shape[1]))
self.builder.get_object("resy").set_text(str(img.shape[0]))
self.resolution=(img.shape[1], img.shape[0])
if img.shape[1]<self.screensize[0] and img.shape[0]<self.screensize[1]:
pass
else:
img=imresize(img, (img.shape[0]/2, img.shape[1]/2))
self.axiscc.imshow(img, cmap=cm.gray) #set scale to 0,255 somehow
self.canvascc=FigureCanvasGTKAgg(self.figurecc)
self.canvascc.draw()
self.canvascc.show()
self.builder.get_object("ccimgbox").pack_start(self.canvascc, True, True)
self.builder.get_object("cameraconfig").set_visible(1)
def __init__(self, xdata, ydata, xlabel, ylabel, title):
self.popupwin=gtk.Window()
self.popupwin.set_size_request(600,550)
self.popupwin.set_position(gtk.WIN_POS_CENTER)
self.popupwin.set_border_width(10)
self.xdata = xdata
self.ydata = ydata
vbox = gtk.VBox()
self.fig=Figure(dpi=100)
self.ax = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.main_figure_navBar = NavigationToolbar(self.canvas, self)
self.cursor = Cursor(self.ax, color='k', linewidth=1, useblit=True)
self.canvas.mpl_connect("button_press_event",self.on_press)
self.ax.set_xlabel(xlabel, fontsize = 18)
self.ax.set_ylabel(ylabel, fontsize = 18)
self.ax.set_title(title, fontsize = 18)
self.ax.plot(self.xdata, self.ydata, 'b-', lw=2)
self.textes = []
self.plots = []
vbox.pack_start(self.main_figure_navBar, False, False, 0)
vbox.pack_start(self.canvas, True, True, 2)
self.popupwin.add(vbox)
self.popupwin.connect("destroy", self.dest)
self.popupwin.show_all()
def drawMonitorTest(self):
try:
self.builder.get_object("tmcspace").remove(self.canvastmc)
self.axistmc.clear()
except:
pass
#Add cropping
self.axistmc.imshow(self.tmonimage, cmap=cm.gray) #set scale to 0,255 somehow
#Maybe this needn't be redefined for every draw - only need draw() but not drawn often anyway
self.canvastmc=FigureCanvasGTKAgg(self.figuretmc)
self.canvastmc.draw()
self.canvastmc.show()
self.builder.get_object("tmcspace").pack_start(self.canvastmc, True, True)
for i in range(len(self.trlist)):
for cont in self.contours:
#if self.rlist[i]==cont.ritem:
#TODO remove hidden parameters here
if np.abs(self.trlist[i][0][0]-cont.ritem[0][0])<=4 and np.abs(self.trlist[i][0][1]-cont.ritem[0][1])<=4:
item=self.trlist[i]
r=Rectangle(item[0], item[1], item[2], fill=False, color="blue")
self.axistmc.add_patch(r)
#could add width, height check as well
#Always draw saved contours in blue
for ditem in self.contours:
item=ditem.ritem
def __init__(self):
gladefile = 'fluviewer.glade'
# This must match the window name in glade
windowname = 'fluviewer'
self.wTree = gtk.glade.XML(gladefile, windowname)
dic = {
# Also need to set fluviewer's signal tab
'on_fluviewer_destroy': gtk.main_quit,
'on_tv_country_button_release_event': self.on_tv_country_changed,
'on_tv_country_key_release_event': self.on_tv_country_changed,
'on_btn_update_clicked': self.on_btn_update_clicked,
}
self.wTree.signal_autoconnect (dic)
self.fluviewer = self.wTree.get_widget('fluviewer')
# Load CSV if it is in current directory
self.update(False)
self.reload()
# Setting up figure
self.figure = Figure()
self.axis = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self.figure)
vbox = self.wTree.get_widget('vbox2')
vbox.pack_start(self.canvas, True, True)
# Setting figure navigation toolbar
vbox.pack_start(NavigationToolbar(self.canvas, self.fluviewer), False, False)
vbox.show_all()
def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
"""
Create a new instance of the ASAPlot plotting class.
If rows < 1 then a separate call to set_panels() is required to define
the panel layout; refer to the doctext for set_panels().
"""
v = vars()
del v['self']
asaplotbase.__init__(self, **v)
matplotlib.rcParams['interactive'] = True
matplotlib.interactive = True
_pylab_helpers.Gcf.destroy(0)
self.canvas = FigureCanvas(self.figure)
# Simply instantiating this is enough to get a working toolbar.
self.figmgr = FigureManagerGTKAgg(self.canvas, 1)
def dest_callback(val):
self.is_dead = True
self.figmgr.window.destroy()
self.window = self.figmgr.window
self.window.connect("destroy", dest_callback )
self.window.set_title('ASAP Plotter - GTK')
#self.canvas.set_size_request(800,600)
_pylab_helpers.Gcf.figs[self.figmgr.num] = self.figmgr
def init(self):
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_size_request(-1, 50)
self.pack_start(toolbar, False, False, 0)
tool_bar_pos=0
save = gtk.ToolButton(gtk.STOCK_SAVE)
save.connect("clicked", self.callback_save_image)
toolbar.insert(save, tool_bar_pos)
toolbar.show_all()
tool_bar_pos=tool_bar_pos+1
self.my_figure=Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.my_figure) # a gtk.DrawingArea
self.canvas.figure.patch.set_facecolor('white')
self.canvas.set_size_request(600, 400)
self.canvas.show()
self.pack_start(self.canvas, False, False, 0)
self.canvas.connect('key_press_event', self.on_key_press_event)
self.show_all()
def refreshGraphDisplay( self ):
# Remove existing graph items
if self.graphCanvas != None:
self.vboxGraphs.remove( self.graphCanvas )
self.graphCanvas.destroy()
self.graphCanvas = None
if self.graphNavToolbar != None:
self.vboxGraphs.remove( self.graphNavToolbar )
self.graphNavToolbar.destroy()
self.graphNavToolbar = None
# Draw the graphs
self.graphFigure = Figure( figsize=(8,6), dpi=72 )
self.graphAxis = self.graphFigure.add_subplot( 111 )
#self.graphAxis.plot( range( 1, len( self.maxMotionCounts )+1 ), self.maxMotionCounts )
diffs = [ 0 ] + [ self.leftMostMotionList[ i+1 ] - self.leftMostMotionList[ i ] for i in range( len( self.leftMostMotionList ) - 1 ) ]
#self.graphAxis.plot( range( 1, len( self.leftMostMotionList )+1 ), self.leftMostMotionList )
self.graphAxis.plot( range( 1, len( self.leftMostMotionList )+1 ), diffs )
# Build the new graph display
self.graphCanvas = FigureCanvas( self.graphFigure ) # a gtk.DrawingArea
self.graphCanvas.show()
self.graphNavToolbar = NavigationToolbar( self.graphCanvas, self.window )
self.graphNavToolbar.lastDir = '/var/tmp/'
self.graphNavToolbar.show()
# Show the graph
self.vboxGraphs.pack_start( self.graphNavToolbar, expand=False, fill=False )
self.vboxGraphs.pack_start( self.graphCanvas, True, True )
self.vboxGraphs.show()
self.vboxGraphs.show()
def __init__(self, NetworkTable):
util.initialize_from_xml(self)
self.dead = False
self.plots = []
self.count = 0
self.netTable = NetworkTable
self.netTable.PutBoolean('EnableTuning', True)
self.figure = Figure(figsize=(5, 4), dpi=100)
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea
self.graphImage = util.replace_widget(self.graphImage, self.canvas)
self.toolbar = util.replace_widget(
self.toolbar, NavigationToolbar(self.canvas, self.window))
self.window.show_all()
# listen to network tables variables
network_tables.attach_fn(self.netTable, "Catapult Values",
self.on_update_CatapultValues, self.window)
network_tables.attach_fn(self.netTable, "EnableTuning",
self.on_update_EnableTuning, self.window)
def __init__(self, xs, ys):
self.xs=xs
self.ys=ys
self.win = gtk.Window()
self.win.connect("destroy", lambda x: gtk.main_quit())
self.win.set_default_size(800,600)
self.win.set_title("openSpectrometer")
self.vbox = gtk.VBox()
self.win.add(self.vbox)
self.fig = Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.ax = self.fig.add_subplot(111)
self.canvas.mpl_connect('pick_event', self.onpick)
self.vbox.pack_start(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self.win)
self.hbox = gtk.HBox()
self.button=gtk.Button('Select this point as lambda max')
self.button.connect("clicked", self.buttonClick)
self.hbox.pack_start(self.toolbar)
self.hbox.pack_start(self.button)
self.vbox.pack_start(self.hbox, False, False)
self.lastind = 0
self.text = self.ax.text(0.05, 0.95, 'Datapoint index selected: none',
transform=self.ax.transAxes, va='top')
def main(params):
global fig, paths_img_csv, actual_idx, df_info_all
win = gtk.Window()
win.set_default_size(600, 400)
win.set_title('Annotation (correction) egg centers')
win.connect('destroy', lambda x: gtk.main_quit())
fig = Figure()
fig.subplots_adjust(left=0, bottom=0, right=1, top=1)
canvas = FigureCanvasGTKAgg(fig) # a gtk.DrawingArea
win.add(canvas)
actual_idx = 0
paths_img_csv = load_paths_image_csv(params)
logging.info('loaded %i pairs (image & centers)', len(paths_img_csv))
assert paths_img_csv, 'missing paths image - csv'
if params['path_info'] is not None and os.path.isfile(params['path_info']):
df_info_all = pd.read_csv(params['path_info'], sep='\t', index_col=0)
else:
df_info_all = None
logging.info('loaded complete info')
canvas_load_image_centers()
fig.canvas.mpl_connect('button_press_event', onclick)
win.connect('key-release-event', onkey_release)
win.show_all()
gtk.main()
def FileLoad(self, widget):
self.points=[]
self.folder=widget.get_filenames()[0] #get full path
self.filenames = os.listdir(self.folder)
i=0
while i<len(self.filenames):
if self.filenames[i][-3:]!="BMP" and self.filenames[i][-3:]!="bmp":
self.filenames.pop(i)
else:
self.filenames[i]=self.folder+"/"+self.filenames[i]
i+=1
if len(self.filenames)==0:
if self.curid!=None:
self.builder.get_object("statusbar").remove_message(self.conid, self.curid)
self.curid=self.builder.get_object("statusbar").push(self.conid, "Error: No BMPs in given folder!")
return 0
self.filenames.sort()
try:
self.datafilename=self.filenames[0].split("/")[-1].split("_")[0]+self.timestr+".dat"
except:
self.datafilename=self.filenames[0].split("/")[-1].split(".")[0]+self.timestr+".dat"
self.builder.get_object("toolbar1").set_sensitive(1)
if (self.filenames[0].split(".")[-1]=="bmp") or (self.filenames[0].split(".")[-1]=="BMP"):
self.origin="lower"
else:
self.origin="upper"
#Reset other data here - TODO
for filen in self.filenames: #no faster
self.images.append(mpimg.imread(filen))
self.figure=Figure()
self.axis=self.figure.add_subplot(111)
img=mpimg.imread(self.filenames[0])
self.frame=0
self.points.append({"base1":None, "base2":None, "tail1":None, "tail2":None, "angle":None, "side":None, "topbottom":None, "length":None})
self.axis.imshow(img, origin=self.origin)
self.canvas=FigureCanvasGTKAgg(self.figure)
self.canvas.show()
self.canvas.mpl_connect('motion_notify_event', self.HoverOnImage)
self.canvas.mpl_connect('button_release_event', self.CaptureClick)
self.builder.get_object("npbox").pack_start(self.canvas, True, True)
self.builder.get_object("pklchoose").set_sensitive(1)
self.SetClickState("base1")
self.UpdateInstructions("Zoom in and click two points along the dog's feet to draw the base line")
class WidgetsWrapper:
def __init__(self):
self.widgets = gtk.glade.XML('test.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self['windowMain'].connect('destroy', lambda x: gtk.main_quit())
self['windowMain'].move(10, 10)
self.figure = Figure(figsize=(8, 6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axis.plot(t, s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.canvas.set_size_request(600, 400)
def onselect(xmin, xmax):
print xmin, xmax
span = HorizontalSpanSelector(self.axis,
onselect,
useblit=False,
rectprops=dict(alpha=0.5,
facecolor='red'))
self['vboxMain'].pack_start(self.canvas, True, True)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, True, True)
self['vboxMain'].reorder_child(self['buttonClickMe'], -1)
def __getitem__(self, key):
return self.widgets.get_widget(key)
class aacxGui:
def __init__(self):
self.builder = gtk.Builder()
self.builder.add_from_file("aacx.ui")
self.window = self.builder.get_object("window1")
self.status = self.builder.get_object("statusbar1")
self.frmadj = self.builder.get_object("frame_adj")
self.about = gtk.AboutDialog()
self.about.set_name("AACX")
self.about.set_version("0.0.1")
self.about.set_copyright(u'Copyright © 2010 Alex Converse')
self.about.set_website("http://github.com/aconverse/aacx")
self.about.set_license("GPLv2+")
self.window.connect("destroy", gtk.main_quit)
signals = {
"on_file_quit_activate": gtk.main_quit,
"on_help_about_activate": self.show_about,
"on_frame_adj_value_changed": self.spinback,
}
self.builder.connect_signals(signals)
self.set_status_here("xxx")
self.hasplot = 0
def addplot(self, fig):
self.canvas = FigureCanvasGTKAgg(fig)
self.canvas.show()
v = self.builder.get_object("vbox1")
v.pack_start(self.canvas)
self.hasplot = 1
def redraw(self):
self.canvas.draw()
def show(self):
self.window.show()
def show_about(self, data):
self.about.run()
self.about.hide()
def set_status_here(self, text):
self.status.push(0, text)
def spinback(self, data):
spinback(int(data.get_value()), int(data.get_upper())+1)
def set_spinner(self, n):
self.frmadj.set_value(n)
def set_num_frames(self, n):
self.frmadj.set_upper(n-1)
def __init__(self, plot, width=500, height=500):
super(PlotWidget, self).__init__()
self.widget = FigureCanvas(plot.get_figure())
self.plot = plot
self.logger = plot.logger
self.widget.set_size_request(width, height)
self.widget.show_all()
def __init__(self):
self.widgets = gtk.glade.XML('mpl_with_glade.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self['windowMain'].connect('destroy', lambda x: gtk.main_quit())
self['windowMain'].move(10, 10)
self.figure = Figure(figsize=(8, 6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axis.plot(t, s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.canvas.set_size_request(600, 400)
self.canvas.set_events(gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.KEY_PRESS_MASK
| gtk.gdk.KEY_RELEASE_MASK)
self.canvas.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS)
self.canvas.grab_focus()
def keypress(widget, event):
print('key press')
def buttonpress(widget, event):
print('button press')
self.canvas.connect('key_press_event', keypress)
self.canvas.connect('button_press_event', buttonpress)
def onselect(xmin, xmax):
print(xmin, xmax)
span = SpanSelector(self.axis,
onselect,
'horizontal',
useblit=False,
rectprops=dict(alpha=0.5, facecolor='red'))
self['vboxMain'].pack_start(self.canvas, True, True)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, True, True)
self['vboxMain'].reorder_child(self['buttonClickMe'], -1)
class PlotWidget(Widgets.WidgetBase):
def __init__(self, plot, width=500, height=500):
super(PlotWidget, self).__init__()
self.widget = FigureCanvas(plot.get_figure())
self.plot = plot
self.logger = plot.logger
self.widget.set_size_request(width, height)
self.widget.show_all()
def set_plot(self, plot):
self.plot = plot
self.logger = plot.logger
self.logger.debug("set_plot called")
def configure_window(self, wd, ht):
self.logger.debug("canvas resized to %dx%d" % (wd, ht))
fig = self.plot.get_figure()
fig.set_size_inches(float(wd) / fig.dpi, float(ht) / fig.dpi)
def drawDefault(self):
logging.debug('>>')
self.axis = self.figure.add_subplot(111)
self.axis.set_xlabel('Yepper')
self.axis.set_ylabel('Flabber')
self.axis.set_title('An Empty Graph')
self.axis.grid(True)
self.canvas.destroy()
self.canvas = FigureCanvasGTK(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.vbox.pack_start(self.canvas, True, True)
logging.debug('<<')
def __init__(self):
self.builder = gtk.Builder()
self.builder.add_from_file('iverplot.glade')
self.builder.connect_signals(self)
self.window = self.builder.get_object('main_window')
# add matplotlib figure canvas
w, h = self.window.get_size()
self.fig = Figure(figsize=(6, 4))
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.canvas.set_size_request(w - 150, -1)
vbox = gtk.VBox()
toolbar = NavigationToolbar(self.canvas, self.window)
vbox.pack_start(self.canvas, True, True)
vbox.pack_start(toolbar, False, False)
# a little hacky for packing hpane with figure canvas first then tool
# bar---not sure if glade is to blame---first, remove tool_vbox then
# repack
plot_hpaned = self.builder.get_object('plot_hpaned')
self.tool_vbox = self.builder.get_object('tool_vbox')
plot_hpaned.remove(self.tool_vbox)
#plot_hpaned.pack1 (self.canvas, resize=True, shrink=False)
plot_hpaned.pack1(vbox, resize=True, shrink=False)
plot_hpaned.pack2(self.tool_vbox)
# data
self.uvclog = None
self.lcmlog = None
# plot limits
self.xlimits = [None, None]
self.xlimits_abs = [None, None]
# add single plot item
self.plotdex = {}
self.plot_items = []
self.plot_items.append(
Plot_item(self.tool_vbox, self.on_plot_item_selected, self.uvclog,
self.lcmlog))
self.update_subplots()
# setwin
self.setwin = None
# set some defaults
self.cd_saveas = os.getcwd()
self.cd_open = os.getcwd()
self.window.show_all()
def __init__(self, title, function, labels):
self.title = title
# MAT-PLOT-LIB_____________________________________________________
self.fig = Figure(figsize=(6, 4)) # create fig
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.canvas.set_size_request(500, 300) # set min size
self.markers = [
'.', ',', '+', 'x', '|', '_', 'o', 'v', '^', '<', '>', '8', 's',
'p', '*', 'h', 'H', 'D', 'd'
]
self.colors = [
'black', 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow',
'purple', 'white'
]
self.pstyle = [
'bmh', 's', '6', 'red', '0.8', 'black', '2', 'black', '0.3', '',
'25', '', '', '20', '15', '', '', '20', '15'
]
self.styledict = {}
self.styledict["style"] = 'bmh'
self.styledict["point_style"] = 's'
self.styledict["point_size"] = '6'
self.styledict["point_color"] = 'red'
self.styledict["point_alpha"] = '0.8'
self.styledict["line_color"] = 'black'
self.styledict["line_width"] = '2'
self.styledict["band_color"] = 'black'
self.styledict["band_alpha"] = '0.3'
self.styledict["title_size"] = '25'
self.styledict["xtitle_size"] = '20'
self.styledict["xlabel_size"] = '15'
self.styledict["ytitle_size"] = '20'
self.styledict["ylabel_size"] = '15'
self.nselec = [1, 12, 5, 3, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1]
self.plot_labels = []
self.plot_labels.append(labels[3] + " vs " + labels[0]) # plot title
self.plot_labels.append(labels[0]) # x-axis title
self.plot_labels.append(labels[3]) # y-axis title
self.plot_labels.append("[Gy]") # x-axis unit
self.plot_labels.append(" ") # y-axis unit
#print plt.style.available
self.fit_toggle = 'inactive'
self.points_toggle = 1
self.function_toggle = 1
self.err_toggle = 1
self.ci_func_toggle = 1
self.ci_points_toggle = 1
def __init__(self, plotters, fields):
gtk.VBox.__init__(self)
self.figure = mpl.figure.Figure()
self.canvas = FigureCanvas(self.figure)
self.canvas.unset_flags(gtk.CAN_FOCUS)
self.canvas.set_size_request(600, 400)
self.pack_start(self.canvas, True, True)
self.canvas.show()
self.navToolbar = NavigationToolbar(self.canvas, self.window)
#self.navToolbar.lastDir = '/tmp'
self.pack_start(self.navToolbar, False, False)
self.navToolbar.show()
self.checkboxes = gtk.HBox(len(plotters))
self.pack_start(self.checkboxes, False, False)
self.checkboxes.show()
self.pol = (1 + 0j, 0j)
self.pol2 = None
self.handlers = []
i = 0
self.plots = []
for plotterClass, default in plotters:
axes = self.figure.add_subplot(len(plotters), 1, i)
def makeUpdateInfo(i):
return lambda s: self.__updateInfo(i, s)
def makeUpdatePos(i):
return lambda s: self.__updatePos(i, s)
plotter = plotterClass(axes, fields, makeUpdateInfo(i),
makeUpdatePos(i))
d = PlottedData(axes, plotter, default, self.__updateChildren)
self.checkboxes.pack_start(d.checkBox, False, False)
self.plots.append(d)
i += 1
self.__infos = [None] * len(self.plots)
self.__posi = None
self.legendBox = gtk.CheckButton("Show legend")
self.legendBox.set_active(True)
self.legendBox.connect("toggled", self.__on_legend_toggled)
self.checkboxes.pack_start(self.legendBox, False, False)
self.legendBox.show()
self.__updateChildren()
class Reader(object):
def __init__(self, win_size, win_loc, title, subplot_dim=[1, 1]):
self.top = gtk.Window()
self.top.connect('delete-event', gtk.main_quit)
self.top.set_title(title)
self.top.set_position(gtk.WIN_POS_CENTER)
self.top.set_default_size(*win_size)
self.fig = Figure()
self.axs = [
self.fig.add_subplot(subplot_dim[0], subplot_dim[1], i + 1)
for i in range(np.prod(subplot_dim))
]
self.canvas = FigureCanvas(self.fig)
self.top.add(self.canvas)
self.top.show_all()
self.update_background()
if len(self.axs) == 1:
self.ax = self.axs[0]
def update_background(self):
self.canvas.draw()
self.backgrounds = [
self.canvas.copy_from_bbox(ax.bbox) for ax in self.axs
]
if len(self.backgrounds) == 1:
self.background = self.backgrounds[0]
return
def draw(self):
raise Exception('Not implemented.')
def read(self):
raise Exception('Not implemented yet.')
def __init__(self, mainThread, gladefile='sensor_window.glade'):
self.builder = gtk.Builder()
self.builder.add_from_file(gladefile)
self.builder.connect_signals(self)
self._stopped = False
self.mainThread = mainThread
self.fig = plt.figure()
self.numLines = 1
# lines plot
self.ax = self.fig.add_subplot(111)
self.ax.set_xlabel('Time')
self.ax.set_ylabel('Power')
self.ax.xaxis.set_animated(True)
self.ax.yaxis.set_animated(True)
self.ax.set_title('Light Intensity')
self.ax.grid(True)
self.start = time.time()
self.background1 = None
self.prev_time = self.start
self.prev_pixel_offset = 0
self.x0 = 0
self.value = [0] * self.numLines
self.ax.set_ylim(-1, 256)
self.lines = []
for i in range(self.numLines):
line, = self.ax.plot([], [], animated=True, lw=2)
self.lines.append(line)
self.canvas = FigureCanvas(self.fig)
self.graphview = self.builder.get_object("box2")
self.graphview.pack_start(self.canvas)
self.graphview.reorder_child(self.canvas, 0)
self.img = self.builder.get_object("image1")
self.img.set_from_file("off.svg")
self.lamp = False
self.canvas.show()
gobject.idle_add(self.update_line)
self.canvas.mpl_connect('draw_event', self.on_draw)
self.barpath = []
def setPlotNotebook(self, builder):
#print "setPlotNotebook: ", self, builder
fig = Figure(figsize=(10,10), dpi=100)
self.ax = fig.add_subplot(111)
self.canvas = FigureCanvas(fig)
notebook = builder.get_object("plotNotebook")
notebook.remove_page(0)
notebook.insert_page(self.canvas, gtk.Label('View Plot'), 0)
self.canvas.show()
# setze wieder auf 1. tab, das remove und insert hat den focus verschoben
notebook.set_current_page(0)
