def __init__(self, tipo):
self.cuento = 0
self.magico = 800
self.app = None
self.tipo = tipo
self.data = np.array([])
self.fechas = np.array([])
self.dpi = 100
self.f = Figure((3.0, 3.0), dpi=self.dpi)
self.f.subplots_adjust(hspace=1, left=.05, right=.99, top=.92)
self.a = self.f.add_subplot(111)
self.a.set_axis_bgcolor('white')
setp(self.a.get_xticklabels(), fontsize=8)
setp(self.a.get_yticklabels(), fontsize=8)
self.plot_data = self.a.plot(
self.data,
linewidth=1.4,
color=tipo.color,
)[0]
self.plot_data2 = self.a.plot(
np.array([]),
linestyle="--",
linewidth=1.4,
color="g",
)[0]
self.a.grid(True)
# self.a.set_xlabel('Time')
self.a.set_ylabel(tipo.formal)
self.canvas = FigureCanvas(self.f)
def __init__(self, owner):
label = "Grayscale analysis"
gtk.Frame.__init__(self, label)
self.owner = owner
self.DMS = self.owner.DMS
self.grayscale_fig = plt.Figure(figsize=(50,40), dpi=100)
self.grayscale_fig.subplots_adjust(left=0.02, right=0.98, wspace=0.3)
self.grayscale_plot_img = self.grayscale_fig.add_subplot(121)
self.grayscale_plot_img.get_xaxis().set_visible(False)
self.grayscale_plot_img.get_yaxis().set_visible(False)
self.grayscale_plot_img_ax = None
self.grayscale_plot_img_ax2 = None
self.grayscale_plot = self.grayscale_fig.add_subplot(122)
self.grayscale_plot.axis("tight")
self.grayscale_plot.get_xaxis().set_visible(False)
grayscale_canvas = FigureCanvas(self.grayscale_fig)
grayscale_canvas.show()
grayscale_canvas.set_size_request(400,150)
self.add(grayscale_canvas)
self.show()
def __init__(self, label):
self.plots = dict()
gtk.Frame.__init__(self)
self.set_label(label)
self.fig = Figure(figsize=(6, 4))
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
#self.add(self.canvas)
vbox = gtk.VBox()
vbox.pack_start(self.canvas)
toolbar = NavigationToolbar(self.canvas, self)
vbox.pack_start(toolbar, False, False)
self.add(vbox)
def setupCanvas(self):
self.f = Figure(figsize=(5, 4),
dpi=100,
subplotpars=SubplotParams(left=0.06,
top=0.95,
right=0.97,
bottom=0.1))
self.setupSubplots()
self.canvas = FigureCanvas(self.f)
#self.canvas.show()
self.lower_vbox.pack_start(self.canvas)
#self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.toolbar = NavigationToolbar(self.canvas, self.window)
self.lower_vbox.pack_start(self.toolbar, False, False)
def clearGraphData(self):
try:
if self.canvas:
self.graphBox.remove(self.canvas)
except:
pass
if self.fig != None:
self.fig.clear()
self.fig = Figure(figsize=(5, 4), dpi=100)
if self.canvas is not None:
self.canvas.destroy()
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
def __init__(self):
self.db = MySQLdb.connect(host="localhost",
user="******",
passwd="",
db="tase")
gtk.Window.__init__(self)
self.set_default_size(600, 600)
self.connect('destroy', self.on_destroy)
self.set_title('TASE')
self.set_border_width(8)
# hbox = gtk.HBox(True, 8)
# self.add(hbox)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
# hbox.pack_start(sw, True, True)
self.treestore = gtk.TreeStore(str)
self.treeview = gtk.TreeView(self.treestore)
col = gtk.TreeViewColumn('Sector', gtk.CellRendererText(), text=0)
self.treeview.append_column(col)
# col = gtk.TreeViewColumn('Subsector', gtk.CellRendererText(), text=1)
# self.treeview.append_column(col)
# col = gtk.TreeViewColumn('Symbol', gtk.CellRendererText(), text=2)
# self.treeview.append_column(col)
#self.cell = gtk.CellRendererText()
#self.tvcolumn.pack_start(self.cell, True)
#self.tvcolumn.add_attribute(self.cell, 'text', 0)
#self.treeview.set_search_column(0)
#self.treeview.connect('row-activated', self.row_activated)
self.treeview.connect('cursor-changed', self.set_cursor)
sw.add(self.treeview)
#self.treeview.show()
self.load_sectors()
# matplotlib stuff
self.fig = Figure(figsize=(6, 4))
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
# hbox.pack_start(self.canvas, True, True)
hpan = gtk.HPaned()
self.add(hpan)
hpan.show()
hpan.pack1(sw, shrink=False)
hpan.pack2(self.canvas, shrink=False)
def __init__(self, title, parent, filename, tmpn, type):
# create matplotlib figure
self.figure = Figure()
self.canvas = FigureCanvas(self.figure)
self.mp = ManipulateXYData(filename,
type,
self.figure,
self,
tmpn=tmpn)
# create GTK dialog
self.dialog = gtk.Dialog(title=title,
parent=parent,
flags=gtk.DIALOG_MODAL
| gtk.DIALOG_DESTROY_WITH_PARENT)
self.dialog.set_default_size(500, 400)
self.vBox = self.dialog.vbox
# setup matplotlib events
self.canvas.mpl_connect('button_press_event', self.mp.on_click)
self.canvas.mpl_connect('button_release_event', self.mp.on_release)
# create buttons
self.buttonBox = gtk.HBox(homogeneous=True, spacing=5)
self.saveButton = gtk.Button(label="Save and Use",
stock=gtk.STOCK_SAVE)
self.useButton = gtk.Button(label="Use")
self.revertButton = gtk.Button(label="Revert")
self.cancelButton = gtk.Button(label="Cancel")
# pack buttons
self.buttonBox.pack_start(self.saveButton, expand=False)
self.buttonBox.pack_start(self.useButton, expand=False)
self.buttonBox.pack_start(self.revertButton, expand=False)
self.buttonBox.pack_end(self.cancelButton, expand=False)
# connect buttons
self.use = False
self.save = False
self.saveButton.connect("clicked", self.saveHandler)
self.useButton.connect("clicked", self.useHandler)
self.revertButton.connect("clicked", self.revertHandler)
self.cancelButton.connect("clicked", self.cancelHandler)
# pack and show dialog
self.vBox.pack_start(self.canvas, expand=True)
self.vBox.pack_start(gtk.HSeparator(), expand=False)
self.vBox.pack_end(self.buttonBox, expand=False)
self.dialog.show_all()
def __init__(self):
# create a new window
window = gtk.Window()
window.set_default_size(400, 300)
window.set_title("DICOM contour display")
# create a figure and plot
self.figure = Figure(figsize=(5, 4), dpi=72)
self.subplot = self.figure.add_subplot(111, projection='3d')
# Create the widget, a FigureCanvas containing our Figure
canvas = FigureCanvas(self.figure)
Axes3D.mouse_init(self.subplot)
vbox = gtk.VBox(homogeneous=False, spacing=0)
vbox.pack_start(canvas, expand=True, fill=True, padding=0)
self.contourselect = gtk.SpinButton(gtk.Adjustment(value=0,
lower=0,
upper=13,
step_incr=1,
page_incr=1),
digits=0)
hbox = gtk.HBox(homogeneous=True, spacing=0)
hbox.pack_start(gtk.Label("Contour to display:"))
hbox.pack_start(self.contourselect)
self.contourselect.connect("value-changed",
lambda x: self.update_contour())
vbox.pack_start(hbox, expand=False, fill=True, padding=0)
window.add(vbox)
self.subplot.plot([0], [0], '-')
self.subplot.grid(True)
self.subplot.set_xlabel('x')
self.subplot.set_ylabel('y')
self.figure.canvas.draw()
# show everything
window.show_all()
window.connect("destroy", lambda x: gtk.main_quit())
def _create_widgets(self):
def create_label(text):
label = gtk.Label(text)
label.show()
return label
self.smoothing_list = gtk.ListStore(str)
smoothing_types = ("Mean-movement", "Savitsky-Golay", _("No smoothing"))
for smt in smoothing_types:
self.smoothing_list.append([smt])
cell = gtk.CellRendererText()
self.smoothing_combo = gtk.ComboBox(self.smoothing_list)
self.smoothing_combo.pack_start(cell, True)
self.smoothing_combo.add_attribute(cell, 'text', 0)
self.smoothing_combo.show()
self.m_spinner = gtk.SpinButton()
self.m_spinner.set_range(5, 25)
self.m_spinner.set_increments(1,5)
self.m_spinner.show()
self.p_spinner = gtk.SpinButton()
self.p_spinner.set_range(1,6)
self.p_spinner.set_increments(1,1)
self.p_spinner.show()
sc_hbox = gtk.HBox()
sc_hbox.pack_start(create_label(_("Smoothing type:")), False, False, 0)
sc_hbox.pack_end(self.smoothing_combo, False, True, 0)
sc_hbox.show()
sm_hbox = gtk.HBox()
sm_hbox.pack_start(create_label(_("Smoothing level(m):")), False, False, 0)
sm_hbox.pack_end(self.m_spinner, False, False, 0)
sm_hbox.show()
sp_hbox = gtk.HBox()
sp_hbox.pack_start(create_label(_("S-G filter order (p):")), False, False, 0)
sp_hbox.pack_end(self.p_spinner, False, False, 0)
sp_hbox.show()
self.sp_hbox = sp_hbox
self.figure = Figure(figsize=(5,4))
self.canvas = FigureCanvas(self.figure)
self.canvas.show()
self.vbox.pack_start(sc_hbox, False, False, 0)
self.vbox.pack_start(sm_hbox, False, False, 0)
self.vbox.pack_start(sp_hbox, False, False, 0)
self.vbox.pack_start(self.canvas, True, True, 0)
self.set_default_size(400,400)
def __init__(self):
'''
init docs
'''
self.window = gtk.Window()
self.window.connect("destroy", lambda x: gtk.main_quit())
self.window.set_default_size(800, 600)
self.figure = Figure()
self.axes_dict = {}
self.canvas = FigureCanvas(self.figure)
self.window.add(self.canvas)
self.redraw = False
gtk.timeout_add(200, self.expose)
def __init__(self, module, mainWindow, preferredWidth, preferredHeight, startWithImage=True): """ Constructor for a Mat Plot Lib Plotter. module - the module using this plotter mainWindow - the MainWindow displaying this plotter preferredWidth - the default width of the plotter preferredHeight - the default height of the plotter startWithImage - a boolean, that if true will display the module's baseimage at first, and switch to the matplotlib plotter when setBaseImageVisible(False) or drawFigure() is called. """ # call the superclass constructor Plotter.__init__(self, module, mainWindow) self.preferredWidth = preferredWidth self.preferredHeight = preferredHeight self.imageVisible = startWithImage path = mainWindow.getPath() if (self.module.baseimage): self.imageFile = self.module.directory + os.sep + self.module.baseimage else: self.imageFile = path + os.sep + "img" + os.sep + "seatree.jpg" self.figure = matplotlib.figure.Figure() self.axis = self.figure.add_subplot(111) self.canvas = FigureCanvas(self.figure) self.bgColor = "white" self.colorMap = matplotlib.cm.Spectral self.evenAspectRatio = True self.climMin = None self.climMax = None self.image = None self.contourLines = False self.contourFills = False self.colorBarOrientation = VERTICAL self.gui = mplSettingsPanel.MPLSettingsPanel(self)
def __init__(self):
"""Initialize an instance of the RAMSTKPlot."""
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_max = []
self._lst_min = [0.0]
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.figure = Figure()
self.plot = FigureCanvas(self.figure)
self.axis = self.figure.add_subplot(111)
def __init__(self):
gtk.Window.__init__(self)
self.connect('destroy', lambda win: gtk.main_quit())
self.set_title('GtkListStore demo')
self.set_border_width(8)
vbox = gtk.VBox(FALSE, 8)
self.add(vbox)
label = gtk.Label('Double click a row to plot the data')
vbox.pack_start(label, FALSE, FALSE)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw, True, True)
model = self.create_model()
self.treeview = gtk.TreeView(model)
self.treeview.set_rules_hint(TRUE)
# matplotlib stuff
fig = Figure(figsize=(6,4))
self.canvas = FigureCanvas(fig) # a gtk.DrawingArea
vbox.pack_start(self.canvas, False, False)
ax = fig.add_subplot(111)
self.line, = ax.plot(self.data[0,:], 'go') # plot the first row
self.treeview.connect('row-activated', self.plot_row)
sw.add(self.treeview)
self.add_columns()
self.set_default_size(600, 600)
self.add_events(gdk.BUTTON_PRESS_MASK |
gdk.KEY_PRESS_MASK|
gdk.KEY_RELEASE_MASK)
def clearGraphData(self):
try:
try:
if self.canvas:
self.graphBox.remove(self.canvas)
except:
pass
if self.fig is not None:
self.fig.clear()
self.fig = Figure(figsize=(5,4), dpi=100)
if self.canvas is not None:
self.canvas.destroy()
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
except:
err = traceback.extract_tb(sys.exc_info()[2])[-1]
print _("Error:")+" "+err[2]+"("+str(err[1])+"): "+str(sys.exc_info()[1])
raise
def __init__(self):
self.db = MySQLdb.connect(host="localhost", user="******", passwd="", db="tase")
gtk.Window.__init__(self)
self.set_default_size(600, 600)
self.connect('destroy', self.on_destroy)
self.set_title('TASE')
self.set_border_width(8)
vbox = gtk.VBox(False, 8)
#self.add(vbox)
vpan = gtk.VPaned()
self.add(vpan)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw, True, True)
button_execute = gtk.Button(label='Execute', stock=None)
button_execute.connect('clicked', self.execute_sql, "execute sql")
vbox.pack_start(button_execute, False, False)
self.buff = gtk.TextBuffer()
query = open("query.txt", 'r').read()
if len(query) > 0:
self.buff.set_text(query)
textview = gtk.TextView(self.buff)
sw.add(textview)
vpan.pack1(vbox, shrink=False)
# matplotlib stuff
self.fig = Figure(figsize=(6,4))
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
#vbox.pack_start(self.canvas, True, True)
vpan.pack2(self.canvas, shrink=False)
vpan.show()
def __init__(self, _components = None, _data=None):
self.components = _components
self.data = _data
gtk.Window.__init__(self,gtk.WINDOW_TOPLEVEL)
self.set_default_size(700,500)
self.set_title("Choose components to use...")
self.connect("delete_event", self.delete_event)
self.connect("destroy", self.delete_event)
self.vbox = gtk.VBox()
self.add(self.vbox)
self.f = Figure(figsize=(5,4), dpi=100, subplotpars=SubplotParams(left=0.06, top=0.95, right=0.97, bottom=0.1))
self.setupSubplots()
self.plotAll()
self.canvas = FigureCanvas(self.f)
self.canvas.mpl_connect('button_press_event', self.cb_canvas)
self.vbox.pack_start(self.canvas)
self.toolbar = NavigationToolbar( self.canvas, self.window )
self.vbox.pack_start(self.toolbar, False, False)
self.show_all()
def __init__(self,
parent,
current_folder=None,
title=_("Open spectra...")):
gtk.FileChooserDialog.__init__(
self,
title=title,
parent=parent,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_ADD,
gtk.RESPONSE_OK))
self.figure = Figure(figsize=(5, 4))
self.canvas = FigureCanvas(self.figure)
self.canvas.set_size_request(200, 200) #tamaño mínimo del widget
self.add_filter(ff_jws)
self.set_select_multiple(True)
if current_folder:
self.set_current_folder(current_folder)
self.set_preview_widget(self.canvas)
self.connect("selection-changed", self._update_preview_cb)
self.show_all()
def __init__(self, img_data):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.connect('key_press_event', self.on_key_press_event)
self.window.set_default_size(400, 300)
self.window.set_title("Gadgetron Image Viewer")
self.vbox = gtk.VBox()
self.window.add(self.vbox)
self.fig = Figure(figsize=(5, 4), dpi=100)
plt.gray()
self.ax = self.fig.add_subplot(111)
self.img_ax = self.ax.imshow(np.squeeze(np.abs(img_data)))
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.vbox.pack_start(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self.window)
self.vbox.pack_start(self.toolbar, False, False)
self.window.show_all()
def __init__(self, window=None, startGtk=0, dims=2):
self.dims = dims
self.data = numpy.zeros((10, 10), numpy.float32)
self.data[:] = numpy.arange(10).astype(numpy.float32)
self.deactivatefn = None #this can be set by the caller, eg to turn off buttons...
self.win = gtk.Window()
self.win.connect("destroy", self.quit)
self.win.set_default_size(400, 400)
self.win.set_title("Window")
self.cmap = colour.gray
self.vbox = gtk.VBox()
self.interpolation = "nearest" #see pylab documantation for others.
self.win.add(self.vbox)
self.vbox.connect("button_press_event", self.buttonPress)
self.fig = Figure(figsize=(5, 4), dpi=50)
self.ax = self.fig.add_subplot(111)
self.fig.subplots_adjust(right=0.99, left=0.08, bottom=0.05, top=0.99)
#self.ax.imshow(self.data,interpolation=self.interpolation)
#print type(fig),dir(ax),dir(fig)
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.vbox.pack_start(self.canvas)
self.toolbar = NavigationToolbar(self.canvas, self.win)
self.vbox.pack_start(self.toolbar, False, False)
self.mytoolbar = myToolbar(plotfn=self.plot)
#self.toolbar.save_figure=self.mytoolbar.mysave
self.vbox.pack_start(self.mytoolbar.toolbar, False, False)
self.win.show_all()
self.toolbar.hide()
self.mytoolbar.toolbar.hide()
self.active = 1 #will be set to zero once quit or window closed.
self.toolbarVisible = 0
self.startedGtk = 0
self.update = 0
#self.plot()
if startGtk == 1 and gtk.main_level() == 0:
self.startedGtk = 1
thread.start_new_thread(gtk.main, ())
gtk.Window
"""
import gtk
from matplotlib.axes import Subplot
from matplotlib.figure import Figure
from numpy import arange, sin, pi
# uncomment to select /GTK/GTKAgg/GTKCairo
from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
#from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
#from matplotlib.backends.backend_gtkcairo import FigureCanvasGTKCairo as FigureCanvas
win = gtk.Window()
win.connect("destroy", lambda x: gtk.main_quit())
win.set_default_size(400, 300)
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)
canvas = FigureCanvas(f) # a gtk.DrawingArea
win.add(canvas)
win.show_all()
gtk.main()
def get_analysis(self, center=None, radius=None):
if radius is None:
self.selection_circ.set_radius(0)
#EMPTYING self.plots_vbox
#for child in self.plots_vbox2.get_children():
# self.plots_vbox2.remove(child)
img_transf = self.get_kodak_image()
if img_transf is None:
return None
x_factor = img_transf.shape[0] / 200
y_factor = img_transf.shape[1] / 200
if x_factor > y_factor:
scale_factor = x_factor
else:
scale_factor = y_factor
if scale_factor == 0:
scale_factor = 1
#
# BLOB SELECTION CANVAS
#
image_size = (img_transf.shape[1]/scale_factor,
img_transf.shape[0]/scale_factor)
#
# RETRIEVING ANALYSIS
#
self._cell = colonies.get_grid_cell_from_array(img_transf, center=center, radius = radius)
self._cell.kodak_data_source = None
self._cell.original_data_source = img_transf.copy()
features = self.get_features()
self.set_features_in_gui(features)
self.DMS("ANALYSE ONE", 'Features: {0}'.format(features),
"L", debug_level="debug")
#
# UPDATE IMAGE SECTION USING CURRENT VALUE SPACE REPRESENTATION
#
if center is None and radius is None:
self.blob_fig_ax.set_data(self._cell.data_source.T)
self.blob_fig_ax.set_clim(vmin = 0,
vmax=(100,3500)[self.last_value_space])
self.blob_fig.gca().add_patch(self.selection_circ)
self.blob_fig.canvas.draw()
#
# GETTING BLOB AND BACKGROUND
#
blob = self._cell.get_item('blob')
self.blob_filter = blob.filter_array
self.blob_image = blob.grid_array
background = self._cell.get_item('background')
#
# CALCULATING CCE IF POLY-COEFFS EXISTS
#
if self._cce_poly_coeffs is not None:
cce_vector = self.get_cce_data_vector(img_section=img_transf)
cce_vector = self.get_expanded_vector(cce_vector)
cce_calculated = self.get_vector_polynomial_sum_single(cce_vector, self._cce_poly_coeffs)
self.cce_calculated.set_text(str(cce_calculated) + " cells in blob")
#
# BLOB vs BACKGROUND CANVAS
#
blob_filter_view = self.blob_filter#.astype(float) * 256 + img_transf
#blob_filter_view = blob_filter_view * ( 256/ float(np.max(blob_filter_view)) )
self.blob_bool_fig_ax.set_data(blob_filter_view.T)
self.blob_bool_fig.canvas.draw()
self.bg_bool_fig_ax.set_data(background.filter_array.T)
self.bg_bool_fig.canvas.draw()
#
# HISTOGRAM
#
blob_hist = blob.histogram
if blob_hist.labels != None:
bincenters = 0.5*(blob_hist.labels[1:]+blob_hist.labels[:-1])
if self._blobs_have_been_loaded == False:
label = gtk.Label("Histogram (Kodak Space):")
label.show()
self.plots_vbox2.pack_start(label, False, False, 2)
self.blob_hist = plt.Figure(figsize=image_size, dpi=150)
self.blob_hist.add_axes()
image_canvas = FigureCanvas(self.blob_hist)
image_plot = self.blob_hist.gca()
image_canvas.set_size_request(300,400)
image_canvas.show()
self.plots_vbox2.pack_start(image_canvas, False, False, 2)
#self.blob_hist.subplots_adjust(top=2, bottom=2)
label = gtk.Label("Threshold (red), Background Mean(green)")
label.show()
self.plots_vbox2.pack_start(label, False, False, 2)
else:
image_plot = self.blob_hist.gca()
image_plot.cla()
#image_plot.bar(blob_hist.labels, blob_hist.counts, linewidth=0, color='k')
image_plot.hist(img_transf.ravel(), bins=150, color='k', alpha=0.6, lw=1)
#image_plot.hist(img_transf[np.where(background.filter_array)].ravel(), bins=150, color='k', alpha=0.6, lw=1)
x_labels = [t.get_text() for t in image_plot.get_axes().get_xticklabels()]
self.DMS('ANALYSE ONE', 'Debugging niceness of plot {0}'.format(\
[str(t) for t in image_plot.get_axes().get_xticklabels()]),
"L", debug_level='debug')
image_plot.get_axes().set_xticklabels(x_labels, fontsize='xx-small')
#if blob_hist.labels != None:
image_plot.axvline(np.mean(img_transf[np.where(\
background.filter_array)]), c='g')
#x_ticks = range(0,256,20)
#image_plot.set_xticks(x_ticks)
#image_plot.set_xticklabels(map(str,x_ticks), fontsize='xx-small')
image_plot.axvline(blob.threshold, c='r')
#image_plot.set_xlim(xmin=0, xmax=100)
self.blob_hist.canvas.draw()
if self._blobs_have_been_loaded == False:
self.plots_vbox2.show_all()
self._blobs_have_been_loaded = True
def __init__(self, owner, label="Analyse One Image"):
gtk.Frame.__init__(self, label)
self.owner = owner
self.DMS = self.owner.DMS
self.KODAK = 0
self.CELL_ESTIMATE = 1
self.analysis = None
self._cell = None
self._rect_marking = False
self._lock_rect_dragging = False
self._rect_ul = None
self._rect_lr = None
self._circ_marking = False
self._circ_dragging = False
self._circ_center = None
self._config_calibration_path = self.owner._program_config_root + os.sep + "calibration.data"
self._config_calibration_polynomial = self.owner._program_config_root + os.sep + "calibration.polynomials"
self._fixture_config_root = self.owner._program_config_root + os.sep + "fixtures"
self.f_settings = None
self._current_fixture = None
self._fixture_updating = False
self.last_value_space = self.KODAK
if os.path.isfile(self._config_calibration_polynomial):
self.last_value_space = self.CELL_ESTIMATE
#
# GTK
#
main_hbox = gtk.HBox()
self.add(main_hbox)
#
# Main image and gray scale
#
self.plots_vbox = gtk.VBox()
main_hbox.pack_start(self.plots_vbox, False, False, 2)
hbox = gtk.HBox()
self.fixture = gtk.combo_box_new_text()
self.reload_fixtures()
self.fixture.connect("changed", self.set_fixture)
hbox.pack_start(self.fixture, False, False, 2)
self.plots_vbox.pack_start(hbox, False, False, 2)
self.grayscale_frame = grayscale.Gray_Scale(self)
self.plots_vbox.pack_start(self.grayscale_frame, False, False, 2)
label = gtk.Label("Marker detection analysis")
self.plots_vbox.pack_start(label, False, False, 2)
figsize = (500,350)
self.image_fig = plt.Figure(figsize=figsize, dpi=75)
image_plot = self.image_fig.add_subplot(111)
image_canvas = FigureCanvas(self.image_fig)
self.image_fig.canvas.mpl_connect('button_press_event', self.plot_click)
self.image_fig.canvas.mpl_connect('button_release_event', self.plot_release)
self.image_fig.canvas.mpl_connect('motion_notify_event', self.plot_drag)
self.selection_rect = plt_patches.Rectangle(
(0,0),0,0, ec = 'k', fill=False, lw=0.5
)
#self.selection_rect.get_axes()
#self.selection_rect.get_transform()
image_plot.add_patch(self.selection_rect)
image_plot.get_xaxis().set_visible(False)
image_plot.get_yaxis().set_visible(False)
image_canvas.set_size_request(figsize[0],figsize[1])
self.plots_vbox.pack_start(image_canvas, False, False, 2)
self.gs_reset_button = gtk.Button(label = 'No image loaded...')
self.gs_reset_button.connect("clicked", self.set_grayscale_selecting)
self.plots_vbox.pack_start(self.gs_reset_button, False, False, 2)
self.gs_reset_button.set_sensitive(False)
#
# BLOB COLUMN
#
self.selection_circ = plt_patches.Circle((0,0),0)
self._blobs_have_been_loaded = False
image_size = [100,100]
self._no_selection = np.zeros(image_size)
self.plots_vbox2 = gtk.VBox()
main_hbox.pack_start(self.plots_vbox2, False, False, 2)
hbox = gtk.HBox()
self.plots_vbox2.pack_start(hbox, False, False, 0)
#selection
vbox = gtk.VBox()
label = gtk.Label("Selection:")
vbox.pack_start(label, False, False, 2)
self.blob_fig = plt.Figure(figsize=image_size, dpi=150)
self.blob_fig.add_axes()
image_plot = self.blob_fig.gca()
self.blob_fig_ax = image_plot.imshow(self._no_selection,
cmap=plt.cm.gray_r)
image_canvas = FigureCanvas(self.blob_fig)
self.blob_fig.canvas.mpl_connect('button_press_event', self.blob_click )
self.blob_fig.canvas.mpl_connect('button_release_event', self.blob_release)
self.blob_fig.canvas.mpl_connect('motion_notify_event', self.blob_drag)
image_plot.get_xaxis().set_visible(False)
image_plot.get_yaxis().set_visible(False)
image_canvas.set_size_request(image_size[1], image_size[0])
vbox.pack_start(image_canvas, False, False, 2)
hbox.pack_start(vbox, False, False, 2)
#blob
vbox = gtk.VBox()
label = gtk.Label("Blob (red)::")
vbox.pack_start(label, False, False, 2)
self.blob_bool_fig = plt.Figure(figsize=image_size, dpi=150)
image_canvas = FigureCanvas(self.blob_bool_fig)
image_canvas.set_size_request(image_size[1], image_size[0])
vbox.pack_start(image_canvas, False, False, 2)
hbox.pack_start(vbox, False, False, 2)
self.blob_bool_fig.add_axes()
image_plot = self.blob_bool_fig.gca()
self.blob_bool_fig_ax = image_plot.imshow(self._no_selection,
vmin=0, vmax=1)
image_plot.get_xaxis().set_visible(False)
image_plot.get_yaxis().set_visible(False)
#background
vbox = gtk.VBox()
label = gtk.Label("Background (red)::")
vbox.pack_start(label, False, False, 2)
self.bg_bool_fig = plt.Figure(figsize=image_size, dpi=150)
image_canvas = FigureCanvas(self.bg_bool_fig)
image_canvas.set_size_request(image_size[1], image_size[0])
vbox.pack_start(image_canvas, False, False, 2)
hbox.pack_start(vbox, False, False, 2)
self.bg_bool_fig.add_axes()
image_plot = self.bg_bool_fig.gca()
self.bg_bool_fig_ax = image_plot.imshow(np.zeros(image_size),
vmin=0, vmax=1)
image_plot.get_xaxis().set_visible(False)
image_plot.get_yaxis().set_visible(False)
#
# DATA COLUMN ETC
#
data_vbox = gtk.VBox()
main_hbox.pack_end(data_vbox, False, False, 2)
hbox = gtk.HBox()
data_vbox.pack_start(hbox, False, False, 2)
label = gtk.Label("Select image:")
hbox.pack_start(label, False, False, 2)
button = gtk.Button(label = 'Open')
button.connect("clicked", self.select_image)
hbox.pack_end(button, False, False, 2)
self.analysis_img = gtk.Label("")
self.analysis_img.set_max_width_chars(40)
self.analysis_img.set_ellipsize(pango.ELLIPSIZE_START)
data_vbox.pack_start(self.analysis_img, False, False, 2)
label = gtk.Label("Manual selection size:")
data_vbox.pack_start(label, False, False, 2)
hbox = gtk.HBox()
data_vbox.pack_start(hbox, False, False, 2)
self.selection_width = gtk.Entry()
self.selection_width.set_text("")
self.selection_width.connect("focus-out-event", self.manual_selection_width)
hbox.pack_start(self.selection_width, False, False, 2)
label = gtk.Label("x")
hbox.pack_start(label, False, False, 2)
self.selection_height = gtk.Entry()
self.selection_height.set_text("")
self.selection_height.connect("focus-out-event", self.manual_selection_height)
hbox.pack_start(self.selection_height, False, False, 2)
checkbox = gtk.CheckButton(label="Lock selection size", use_underline=False)
checkbox.connect("clicked", self.set_lock_selection_size)
data_vbox.pack_start(checkbox, False, False, 2)
#Analysis data frame for selection
frame = gtk.Frame("Image")
data_vbox.pack_start(frame, False, False, 2)
vbox3 = gtk.VBox()
frame.add(vbox3)
#Interactive helper
self.section_picking = gtk.Label("First load an image.")
vbox3.pack_start(self.section_picking, False, False, 10)
frame.show_all()
button = gtk.RadioButton(None, "Kodak Value Space")
button2 = gtk.RadioButton(button, "Cell Estimate Space")
button2.set_active(self.last_value_space==self.CELL_ESTIMATE)
button.connect("toggled", self.set_value_space, self.KODAK)
data_vbox.pack_start(button, False, False, 2)
button2.connect("toggled", self.set_value_space, self.CELL_ESTIMATE)
data_vbox.pack_start(button2, False, False, 2)
#
# VALUE SPACE
#
#Analysis data frame for selection
self.value_space_frame = gtk.Frame("'{0} Value Space'".format(\
('Kodak','Cell Estimate')[self.last_value_space]))
data_vbox.pack_start(self.value_space_frame, False, False, 2)
vbox3 = gtk.VBox()
self.value_space_frame.add(vbox3)
#Cell Area
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Cell Area:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.cell_area = gtk.Label("0")
self.cell_area.set_selectable(True)
self.cell_area.set_max_width_chars(20)
hbox.pack_end(self.cell_area, False, False, 2)
#Background Mean
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Background Mean:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.bg_mean = gtk.Label("0")
self.bg_mean.set_selectable(True)
hbox.pack_end(self.bg_mean, False, False, 2)
#Background Inter Quartile Range Mean
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Background IQR-Mean:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.bg_iqr_mean = gtk.Label("0")
self.bg_iqr_mean.set_selectable(True)
hbox.pack_end(self.bg_iqr_mean, False, False, 2)
#Background Median
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Background Median:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.bg_median = gtk.Label("0")
self.bg_median.set_selectable(True)
hbox.pack_end(self.bg_median, False, False, 2)
#Blob area
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Blob Area:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.blob_area = gtk.Label("0")
self.blob_area.set_selectable(True)
hbox.pack_end(self.blob_area, False, False, 2)
#Blob Size
#hbox = gtk.HBox()
#vbox3.pack_start(hbox, False, False, 2)
#label = gtk.Label("Blob Size:")
#hbox.pack_start(label,False, False, 2)
#self.colony_size = gtk.Label("0")
#hbox.pack_end(self.colony_size, False, False, 2)
#Blob Pixelsum
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Blob Pixelsum:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.blob_pixelsum = gtk.Label("0")
self.blob_pixelsum.set_selectable(True)
hbox.pack_end(self.blob_pixelsum, False, False, 2)
#Blob Mean
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("Blob Mean:")
label.set_selectable(True)
hbox.pack_start(label,False, False, 2)
self.blob_mean = gtk.Label("0")
self.blob_mean.set_selectable(True)
hbox.pack_end(self.blob_mean, False, False, 2)
#
# CALIBRATION FRAME
#
#Cell Count Estimations
self.calibration_frame = gtk.Frame("Cell Estimate Space")
data_vbox.pack_start(self.calibration_frame, False, False, 2)
vbox3 = gtk.VBox()
self.calibration_frame.add(vbox3)
#Unit
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
self.cce_per_pixel = gtk.Label("0")
hbox.pack_start(self.cce_per_pixel)
label = gtk.Label("depth/pixel")
hbox.pack_end(label, False, False, 2)
label = gtk.Label("Independent measure:")
vbox3.pack_start(label, False, False, 2)
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label("CCE/grid-cell:")
hbox.pack_start(label, False, False, 2)
self.cce_indep_measure = gtk.Entry()
self.cce_indep_measure.connect("focus-out-event", self.verify_number)
hbox.pack_end(self.cce_indep_measure, False, False, 2)
hbox = gtk.HBox()
vbox3.pack_start(hbox, False, False, 2)
label = gtk.Label('Data point label:')
hbox.pack_start(label, False, False, 2)
self.cce_data_label = gtk.Entry()
hbox.pack_end(self.cce_data_label, False, False, 2)
button = gtk.Button("Submit calibration point")
button.connect("clicked", self.add_calibration_point, None)
vbox3.pack_start(button, False, False, 2)
self.cce_calculated = gtk.Label("--- cells in blob")
vbox3.pack_start(self.cce_calculated, False, False, 2)
self._cce_poly_coeffs = None
has_poly_cal = True
try:
fs = open(self._config_calibration_polynomial, 'r')
except:
has_poly_cal = False
if has_poly_cal:
self._cce_poly_coeffs = []
for l in fs:
l_data = eval(l.strip("\n"))
if type(l_data) == types.ListType:
self._cce_poly_coeffs = l_data[-1]
break
label = gtk.Label("(using '" + str(l_data[0]) + "')")
self.DMS("ANALYSIS ONE", "Using polynomial: {0}".format(\
self._cce_poly_coeffs), "L", debug_level="info")
vbox3.pack_start(label, False, False, 2)
fs.close()
self.blob_filter = None
main_hbox.show()
self.plots_vbox.show_all()
data_vbox.show_all()
self.value_space_frame.show_all()
self.set_value_space(widget=None, value_space=self.last_value_space)
def __init__(self, title, parent, syn2d, numX, numY):
# create buttons
self.loadButton = gtk.Button(label="Load", stock=gtk.STOCK_OPEN)
self.saveButton = gtk.Button(label="Save and Use",
stock=gtk.STOCK_SAVE)
self.useButton = gtk.Button(label="Use")
self.revertButton = gtk.Button(label="Revert")
self.clearButton = gtk.Button(label="Clear")
self.cancelButton = gtk.Button(label="Cancel")
# create matplotlib figure
self.figure = Figure()
self.canvas = FigureCanvas(self.figure)
self.mp = DataPointChooser(self.figure, self, numX, numY)
self.syn2d = syn2d
self.parent = parent
self.sourcesFile, self.receiversFile = self.syn2d.getDataFiles()
print "Loading initial data from: " + self.sourcesFile + " , " + self.receiversFile
sources = self.loadXYFile(self.sourcesFile)
receivers = self.loadXYFile(self.receiversFile, True)
# create GTK dialog
self.dialog = gtk.Dialog(title=title,
parent=parent,
flags=gtk.DIALOG_MODAL
| gtk.DIALOG_DESTROY_WITH_PARENT)
self.dialog.set_default_size(500, 400)
self.vBox = self.dialog.vbox
# setup matplotlib events
self.canvas.mpl_connect('button_press_event', self.mp.on_click)
# pack buttons
self.buttonBox = gtk.HBox(homogeneous=True, spacing=5)
self.buttonBox.pack_start(self.loadButton, expand=False)
self.buttonBox.pack_start(self.saveButton, expand=False)
self.buttonBox.pack_start(self.useButton, expand=False)
self.buttonBox.pack_start(self.revertButton, expand=False)
self.buttonBox.pack_start(self.clearButton, expand=False)
self.buttonBox.pack_end(self.cancelButton, expand=False)
# connect buttons
self.use = False
self.loadButton.connect("clicked", self.loadHandler)
self.saveButton.connect("clicked", self.saveHandler)
self.useButton.connect("clicked", self.useHandler)
self.revertButton.connect("clicked", self.revertHandler)
self.clearButton.connect("clicked", self.clearHandler)
self.cancelButton.connect("clicked", self.cancelHandler)
self.label = gtk.Label(
"Mouse Buttons: L-Add Station, M-Delete Point, R-Add Source")
# pack and show dialog
self.vBox.pack_start(self.canvas, expand=True)
self.vBox.pack_start(gtk.HSeparator(), expand=False)
self.vBox.pack_start(self.label, expand=False)
self.vBox.pack_end(self.buttonBox, expand=False)
self.mp.setOriginalData(sources, receivers)
self.mp.reset_data()
self.dialog.show_all()
