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()