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()
class JwsFileChooserDialog(gtk.FileChooserDialog):
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 _update_preview_cb(self, widget):
input_fn = self.get_preview_filename()
error = True
if input_fn is not None:
results = jwslib.read_file(input_fn)
if results[0] == jwslib.JWS_ERROR_SUCCESS:
header = results[1]
channels = results[2]
if len(channels) > 0:
error = False
if not error:
xdata = arange(
header.x_for_first_point, #start
header.x_for_last_point + header.x_increment, #end+incr.
header.x_increment) #increment
ellipticity = array(channels[0], float32)
self.figure.clear()
p = self.figure.add_subplot(111)
p.plot(xdata, ellipticity)
self.canvas.draw()
self.set_preview_widget_active(not error)
class JwsFileChooserDialog(gtk.FileChooserDialog):
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 _update_preview_cb(self, widget):
input_fn = self.get_preview_filename()
error = True
if input_fn is not None:
results = jwslib.read_file(input_fn)
if results[0] == jwslib.JWS_ERROR_SUCCESS:
header = results[1]
channels = results[2]
if len(channels) > 0:
error = False
if not error:
xdata = arange(
header.x_for_first_point, # start
header.x_for_last_point + header.x_increment, # end+incr.
header.x_increment,
) # increment
ellipticity = array(channels[0], float32)
self.figure.clear()
p = self.figure.add_subplot(111)
p.plot(xdata, ellipticity)
self.canvas.draw()
self.set_preview_widget_active(not error)
class mainGUI:
#====================
#constructor
#====================
def __init__(self):
# Create main window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Dan's crazy gene regulation simulator")
self.window.set_border_width(2)
self.window.connect("delete_event",self.close)
#window size values
self.x_size = 640
self.y_size = 480
self.design_Window_Fraction_x = 1.0
self.design_Window_Fraction_y = 0.5
self.button_Window_Fraction_x = 0.1
self.button_Window_Fraction_y = 0.5
self.plot_Window_Fraction_x = 0.9
self.plot_Window_Fraction_y = 0.5
#divide up the window
self.main_Box = gtk.VBox(False,0)
self.window.add(self.main_Box)
#Setup circuit design area
self.setup_Design_Area(self.main_Box)
self.sub_Box = gtk.HBox(False,0)
self.main_Box.pack_start(self.sub_Box,True,True,0)
#Setup buttons
self.setup_Buttons(self.sub_Box)
self.setup_Plots(self.sub_Box)
self.sub_Box.show_all()
self.main_Box.show_all()
self.window.show_all()
#====================
#Init helpers
#====================
def setup_Design_Area(self,box):
self.design_Area = gtk.Fixed()
self.design_Area.set_size_request(int(self.design_Window_Fraction_x*self.x_size),
int(self.design_Window_Fraction_y*self.y_size))
self.design_Area.set_has_window(True)
box.pack_start(self.design_Area,True,True,0)
self.design_Area.show()
self.gene_Collection = Gene_Collection(self.design_Area)
self.design_Area.connect("button-press-event",self.create_Object,"")
def setup_Buttons(self,box):
self.button_Box = gtk.VBox(False,0)
self.button_Clear = gtk.Button("Clear")
self.button_Clear.connect("clicked",self.clear,"")
self.button_Clear.show()
self.button_Box.pack_start(self.button_Clear,True,True,0)
self.button_Go = gtk.Button("Go")
self.button_Go.connect("clicked",self.runSim,"")
self.button_Box.pack_start(self.button_Go,True,True,0)
self.button_Go.show()
self.button_Quit = gtk.Button("Quit")
self.button_Quit.connect("clicked",self.close,"")
self.button_Box.pack_start(self.button_Quit,True,True,0)
self.button_Quit.show()
self.button_Box.show()
box.add(self.button_Box)
def setup_Plots(self,box):
self.plot_Figure = Figure(figsize=(5,4), dpi=72)
self.plot = self.plot_Figure.add_subplot(111)
self.plot.plot(0,0,'-')
self.plot_Canvas = FigureCanvas(self.plot_Figure)
self.plot_Canvas.set_size_request(int(self.plot_Window_Fraction_x*self.x_size),
int(self.plot_Window_Fraction_y*self.y_size))
self.plot_Canvas.show()
box.add(self.plot_Canvas)
#====================
#Call backs
#====================
def close(self, widget, event, data=None):
gtk.main_quit()
return False
def clear(self, widget, event, data=None):
print "clear"
def runSim(self, widget, event, data=None):
print "sim"
if(self.gene_Collection.Build_Simulation()):
self.gene_Collection.Run_Simulation()
else:
print "error building simulation"
def create_Object(self, widget, event, data=None):
if(event.button == 1):
if(event.type == gtk.gdk._2BUTTON_PRESS):
self.gene_Collection.Add_New(event)
from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
#from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
import gtk
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)
sw = gtk.ScrolledWindow()
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)
win.show_all()
gtk.main()
class MatPlotLibPlotter(Plotter):
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 tellModuleToReplot(self):
self.module.updatePlot()
def setColorMapByName(self, name, reversed=False, updateGUI=True):
self.colorMap = matplotlib.cm.get_cmap(name=name)
#print "Reversing? " + str(reversed)
# set our custom 'seatree_reversed' flag
try:
dummy = self.colorMap.seatree_reversed
# print "it has a reversed flag!"
except:
# print "it doesn't have a reversed flag!"
self.colorMap.seatree_reversed = False
# print "Reversing? " + str(reversed)
# print "Already Reversed? " + str(self.colorMap.seatree_reversed)
if reversed != self.colorMap.seatree_reversed:
# print "lets flip it!"
self.colorMap = self.reverseColormap(self.colorMap)
self.colorMap.seatree_reversed = reversed
if updateGUI:
self.gui.loadOptionsFromPlotter()
def reverseColormap(self, cm):
# print cm._segmentdata['red']
#self.__reverseCMComponent(cm, 'red')
#self.__reverseCMComponent(cm, 'blue')
#self.__reverseCMComponent(cm, 'green')
segData = dict()
numSegs = len(cm._segmentdata['red'])
reds = []
for i in range(numSegs):
index = numSegs - i - 1
val = self.colorMap._segmentdata['red'][index]
reds.append((1 - val[0], val[1], val[2]))
numSegs = len(cm._segmentdata['blue'])
blues = []
for i in range(numSegs):
index = numSegs - i - 1
val = self.colorMap._segmentdata['blue'][index]
blues.append((1 - val[0], val[1], val[2]))
numSegs = len(cm._segmentdata['green'])
greens = []
for i in range(numSegs):
index = numSegs - i - 1
val = self.colorMap._segmentdata['green'][index]
greens.append((1 - val[0], val[1], val[2]))
segData = {'red': reds, 'blue': blues, 'green': greens}
newCM = matplotlib.colors.LinearSegmentedColormap(cm.name,segData,1024)
#cm._segmentdata = segData
# print newCM._segmentdata['red']
newCM.seatree_reversed = True
return newCM
def isColorMapReversed(self, colorMap=None):
if colorMap == None:
colorMap = self.colorMap
try:
if self.colorMap.seatree_reversed:
return True
except:
self.colorMap.seatree_reversed = False
return False
return False
def setColorMap(self, colorMap):
self.colorMap = colorMap
self.gui.loadOptionsFromPlotter()
def getColorMap(self):
return self.colorMap
def setColorbarOrientation(self, orientation):
self.colorBarOrientation = orientation
def applyColorLimits(self):
if self.image != None:
try:
self.image.set_clim(self.climMin, self.climMax)
except:
pass
def setColorLimits(self, min, max, updateGUI=True):
self.climMin = min
self.climMax = max
if updateGUI:
self.gui.loadOptionsFromPlotter()
def getColorLimits(self):
return (self.climMin, self.climMax)
def setContourFills(self, contour):
"""
Plot XYZ data contoured.
contour - boolean that, if true, will contour plots
"""
self.contourFills = contour
def getContourFills(self):
return self.contourFills
def setContourLines(self, contour):
"""
Plot XYZ data contour lines drawn.
contour - boolean that, if true, will contour plots
"""
self.contourLines = contour
def getContourLines(self):
return self.contourLines
def setBaseImageVisible(self, visible):
if (self.imageVisible != visible):
self.imageVisible = visible
self.mainWindow.loadPlotter(self)
def drawFigure(self, applyAspect=True):
self.setBaseImageVisible(False)
if applyAspect:
self.applyAspectRatio()
self.applyColorLimits()
self.canvas.draw()
self.mainWindow.setSaveActive(True)
def addTextLabel(self, x, y, text, **kwargs):
self.figure.text(x, y, text, **kwargs)
def setAxis(self, axis):
self.axis = axis
def getAxis(self):
return self.axis
def getFigure(self):
return self.figure
def getLastImage(self):
return self.image
def clearFigure(self, subplot=111):
self.figure.clear()
if subplot != None:
self.axis = self.figure.add_subplot(subplot)
self.mainWindow.setSaveActive(False)
def getAxisLimits(self, axis=None):
"""
Returns the limits of the axis as a tuple with this format:
[xmin, xmax, ymin, ymax]
"""
if axis == None:
axis = self.axis
x = axis.get_xlim()
y = axis.get_ylim()
return (x[0], x[1], y[0], y[1])
def limitAxis(self, minX, maxX, minY, maxY):
self.minX = minX
self.maxX = maxX
self.minY = minY
self.maxY = maxY
self.axis.set_xlim(minX,maxX)
self.axis.set_ylim(minY,maxY)
def applyAspectRatio(self, axis=None):
if axis == None:
axis = self.axis
if self.evenAspectRatio:
axis._aspect = 'equal'
axis.apply_aspect()
else:
axis._aspect = 'auto'
axis.apply_aspect()
def setAspectRatioEven(self, even):
self.evenAspectRatio = even
def plotXYZFromFile(self, xyzFile, numX, numY, title="", colorBar=False):
"""
Load data from a file and call plotXYZData
"""
a = matplotlib.mlab.load(xyzFile)
n = numX # determine square size
m = numY
# determine geometry
xmin, xmax = min(a[:,0]), max(a[:,0])
ymin, ymax = min(a[:,1]), max(a[:,1])
range = [ xmin , xmax, ymin, ymax ];
# assign three columns to vectors
x=a[:,0].reshape(n,m)
y=a[:,1].reshape(n,m)
z=a[:,2].reshape(n,m)
self.plotXYZData(x,y,z,title,colorBar,range);
def plotXYZFromSquareDataFile(self, xyzFile, title="", colorBar=False):
"""
Load data from a file assuming that the data is given on
an n by n "square" set of points and call plotXYZData
"""
a = matplotlib.mlab.load(xyzFile)
n = int(math.sqrt(a.shape[0])) # determine square size
m = n
# determine geometry
xmin, xmax = min(a[:,0]), max(a[:,0])
ymin, ymax = min(a[:,1]), max(a[:,1])
range = [ xmin , xmax, ymin, ymax ];
# assign three columns to vectors
x=a[:,0].reshape(n,m)
y=a[:,1].reshape(n,m)
z=a[:,2].reshape(n,m)
self.plotXYZData(x,y,z,title,colorBar,range);
def plotXYZData(self, x, y, z, title="", colorBar=False, range=None):
"""
Plot xyz data in vectors x y z
if range is set, will expect four entry vector with limiting range for plot sorted
as [xmin, xmax,ymin,ymax]
"""
if self.contourFills:
self.image = self.axis.contourf(x, y, z, cmap=self.colorMap, shading='flat', extend='both')
else:
self.image = self.axis.pcolor(x, y, z, cmap=self.colorMap, shading='flat')
if self.contourLines:
self.axis.contour(x, y, z, colors='black', linewidths=1, shading='flat', extend='both')
if range != None:
self.limitAxis(range[0],range[1],range[2],range[3]);
if (colorBar):
self.figure.colorbar(self.image, orientation=self.colorBarOrientation)
if (title):
self.axis.set_title(title)
def plotRegularXYZData(self, data, title="", colorBar=False):
"""
Plot xyz data in vectors x y z
if range is set, will expect four entry vector with limiting range for plot sorted
as [xmin, xmax,ymin,ymax]
"""
self.image = self.axis.imshow(data, cmap=self.colorMap)
if self.contourLines:
self.axis.contour(x, y, z, colors='black', linewidths=1, shading='flat', extend='both')
if (colorBar):
self.figure.colorbar(self.image, orientation=self.colorBarOrientation)
if (title):
self.axis.set_title(title)
def addLine(self, xdata, ydata, color='b', **kwargs):
"""
Add a line to the current axis
xdata - numpy array of x values
ydata - numpy array of y values
color - color of the line
"""
line = matplotlib.lines.Line2D(xdata,ydata,color=color,**kwargs)
self.axis.add_line(line)
def addArrow(self, x, y, dx, dy, width=1.0):
arrow = matplotlib.patches.Arrow(x, y, dx, dy, width=width)
self.axis.add_patch(arrow)
def plotScatterData(self, x, y, type=None, color='b', colorMap=None, colorBar=False, size=30, globalWidth=0.2, linewidths=None, setAsImage=True):
if type == None:
type = CIRCLE
if globalWidth != None and not linewidths:
linewidths = []
for i in range(0, len(x)):
linewidths.append(globalWidth)
image = self.axis.scatter(x, y, s=size, c=color, cmap=colorMap, marker=type, linewidths=linewidths)
if setAsImage:
self.image = image
if (colorBar):
self.figure.colorbar(self.image)
def loadXYFile(self, file):
fp = open(file, "r")
lines = fp.readlines()
x = []
y = []
for line in lines:
line = line.strip(" \t\n")
if line.startswith("#"):
continue
lineSplit = line.split()
if len(lineSplit) < 2:
continue
x.append(float(lineSplit[0]))
y.append(float(lineSplit[1]))
return x, y
def plotPolygon(self, polygon, arrows=False, fill=False):
poly = matplotlib.patches.Polygon(polygon, fill=fill)
self.axis.add_patch(poly)
def loadGMTPolygonFile(self, polyFile):
fp = open(polyFile, "r")
lines = fp.readlines()
fp.close()
return self.loadGMTPolygons(lines)
def loadGMTPolygons(self, lines):
polys = []
curPoly = []
for line in lines:
line = line.strip(" \t\n")
if line.startswith(">"):
if len(curPoly) > 0:
#print curPoly
polys.append(curPoly)
curPoly = []
continue
lineSplit = line.split()
if len(lineSplit) < 2:
print "bad polygon line parse!"
continue
poly = []
poly.append(float(lineSplit[0]))
poly.append(float(lineSplit[1]))
#print "added: " + str(poly)
curPoly.append(poly)
return polys
def getMainWidget(self):
if (self.imageVisible):
# return the Image Event Box for this image plotter
self.image = gtk.Image()
self.image.show()
self.imageBuffer = 7
self.imageEB = gtk.EventBox()
self.imageEB.add(self.image)
self.imageEB.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.bgColor))
self.imageEB.set_size_request(self.preferredWidth + self.imageBuffer, self.preferredHeight + self.imageBuffer)
self.image.set_from_file(self.imageFile)
self.mainWindow.setSaveActive(False)
self.imageEB.show_all()
return self.imageEB
else:
self.plotBuffer = 10
self.canvas.show_all()
self.canvas.set_size_request(self.preferredWidth + self.plotBuffer, self.preferredHeight + self.plotBuffer)
return self.canvas
def getBottomPanel(self):
return self.gui
def getSaveTypes(self):
saveTypes = []
saveTypes.append(["png", "PNG Image"])
#saveTypes.append(["ps", "PostScript Plot"]) # should work, but doesn't for some reason
saveTypes.append(["pdf", "Portable Document Format"])
saveTypes.append(["svg", "Scalable Vector Graphics Format"])
return saveTypes
def savePlot(self, typeExtension, fileName):
# don't check for save types since we only have 1
if self.figure != None:
self.figure.savefig(fileName, format=typeExtension)
"""
For some reason matplotlib doesn't reset the pixmap to the on screen one after
rendering, so you can't replot anything until an event like a resize happens. This
will get around that limitation
"""
self.canvas._renderer_init()
self.canvas._pixmap = gtk.gdk.Pixmap (self.canvas.window, self.canvas._pixmap_width,
self.canvas._pixmap_height)
self.canvas._renderer.set_pixmap (self.canvas._pixmap)
return True
return False
def displayImage(self, imageFile, default=False):
"""
This method will display an image file
imageFile - the file name of the image to be displayed
"""
self.imageFile = imageFile
self.image.set_from_file(self.imageFile)
if not default:
self.mainWindow.setSaveActive(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 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
from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
#from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
import gtk
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)
sw = gtk.ScrolledWindow()
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)
win.show_all()
gtk.main()
