I've written a program in wxpython that works just fine in windows but when tested in lunix I have some Display issues that that all occur in linux.
Here is a testapp that demonstrates the problem with the resizing of the FigureCanvasWxAgg in a panel, as seen the panel it self follows the resizingevent but the FigureCanvasWxAgg doesn't follow, this however is not a problem in Windows.
import wx
import matplotlib.figure as plt
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
import wx.lib.inspection
class Test(wx.Frame):
def __init__(self):
super(Test, self).__init__(parent=None, id=-1)
self.figure = plt.Figure()
self.panel = wx.Panel(self, 1)
self.figurepanel = FigureCanvas(self.panel, -1, self.figure)
self.axes1 = self.figure.add_subplot(111)
frame_box = wx.BoxSizer(wx.VERTICAL)
frame_box.AddStretchSpacer(prop=1)
frame_box.Add(self.panel, flag=wx.EXPAND, proportion=2)
frame_box.AddStretchSpacer(prop=1)
main_box = wx.BoxSizer(wx.HORIZONTAL)
main_box.AddStretchSpacer(prop=1)
main_box.Add(frame_box, flag=wx.EXPAND, proportion=1)
main_box.AddStretchSpacer(prop=1)
self.SetSizer(main_box)
self.Show()
self.Layout()
def main():
app = wx.App()
Test()
wx.lib.inspection.InspectionTool().Show()
app.MainLoop()
if __name__ == '__main__':
main()
What I would be very grateful to have answered is:
How do I resolve this issue of reszing FigureCanvasWxAgg in linux
Is there any difference in the general way of GUI programming with wxPython on Windows and in Linux
There are several issues with the code you posted:
You have horizontal and vertical spacer that expand as needed, which causes the central region to remain the same shape
self.figurepanel is not part of any sizer, which means it will not resize even if its container, self.panel does.
The code below produces a window filled by plot that resizes with the window:
import wx
import matplotlib.figure as plt
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
import wx.lib.inspection
class Test(wx.Frame):
def __init__(self):
super(Test, self).__init__(parent=None, id=-1)
self.panel = wx.Panel(self, 1)
self.panel.SetBackgroundColour('RED')
self.figure = plt.Figure()
self.axes1 = self.figure.add_subplot(111)
self.figurepanel = FigureCanvas(self.panel, -1, self.figure)
main_box = wx.BoxSizer(wx.HORIZONTAL)
main_box.Add(self.figurepanel, flag=wx.EXPAND, proportion=1)
self.panel.SetSizer(main_box)
frame_box = wx.BoxSizer(wx.VERTICAL)
frame_box.Add(self.panel, flag=wx.EXPAND, proportion=1)
self.SetSizer(frame_box)
self.Show()
self.Layout()
def main():
app = wx.App()
Test()
wx.lib.inspection.InspectionTool().Show()
app.MainLoop()
if __name__ == '__main__':
main()
There is no need to do any manual resizing yourself, and there is no problem, I think, with resize event propagation. If there is there would be a lot more breakage than what you are seeing.
I think I fixed the problem. The problem is caused by the wx.EVT_SIZE witch seems to be automatic in Windows but not in Linux. So to fix the problem in Linux all you have to do is to bind the the wx.Panel to the wx.EVT_SIZE and then define an apropriate eventhandler that takes care of the resizing.
What did the trick for me was:
#code beneath is a part if the __init__ metod
self.panel = wx.Panel(self, -1)
self.figurepanel = FigureCanvas(self.panel, -1, self.figure)
self.panel.Bind(wx.EVT_SIZE, self.on_size)
....
#the eventhandler for the panel. The method resizes the the figurepanel and the figure.
def on_size(self, event):
pix = self.panel.GetClientSize()
self.figure.set_size_inches(pix[0]/self.figure.get_dpi(),
pix[1]/self.figure.get_dpi())
x,y = self.panel.GetSize()
self.figurepanel.SetSize((x-1, y-1))
self.figurepanel.SetSize((x, y))
self.figurepanel.draw()
event.Skip()
Related
I'm trying to show an image inside a panel of a wxpython notebook page using matplotlib. It works perfectly using wx.StaticBitmap but I need to use matplotlib for image manipulation. The code gives this result:
The right panel is a terminal and sizes correctly. The left panel is where the image is meant to fit. The result of wx.lib.inspection is showing that the wxFigureCanvas minsize is (640, 480) but I don't understand why and can't find how to change that. I suspect it's the problem. The code (sorry, short as I could make it):
import cv2 as cv
import matplotlib.pyplot as plt
from matplotlib.figure import Figure
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
import wx
import wx.lib.agw.aui as aui
class TopRight(wx.Panel):
def __init__(self, parent):
super(TopRight, self).__init__(parent)
self.term = wx.TextCtrl(self,
size=(200, 100),
style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_RICH
)
self.term.SetDefaultStyle(wx.TextAttr(wx.GREEN))
self.term.SetBackgroundColour(wx.BLACK)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.term, 1, wx.EXPAND)
self.SetSizer(self.sizer)
self.term.WriteText("hello")
self.term.Update
class TopLeft(wx.Panel):
def __init__(self, parent):
super(TopLeft , self).__init__(parent)
img_pth = "av_cat.png"
# Intitialise the matplotlib figure
self.figure = Figure()
# Create an axes, turn off the labels and add them to the figure
self.axes = plt.Axes(self.figure,[0,0,1,1])
self.axes.set_axis_off()
self.figure.add_axes(self.axes)
# Add the figure to the wxFigureCanvas
self.canvas = FigureCanvas(self, -1, self.figure)
# Sizer to contain the canvas
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.EXPAND|wx.ALL)
self.SetSizer(self.sizer)
# If there is an initial image, display it on the figure
if img_pth is not None:
self.setImage(img_pth)
def setImage(self, pathToImage):
# Load the image into matplotlib
image = cv.imread(pathToImage)
# Add the image to the figure and redraw the canvas.
self.axes.imshow(image)
self.canvas.draw()
class explorer_panel(wx.Panel):
def __init__(self, parent):
#Constructor
wx.Panel.__init__(self, parent)
topSplitter = wx.SplitterWindow(self)
image_panel = TopLeft(topSplitter)
terminal_panel = TopRight(topSplitter)
topSplitter.SplitVertically(image_panel, terminal_panel)
topSplitter.SetSashGravity(0.5)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(topSplitter, 1, wx.EXPAND)
self.SetSizer(sizer)
class Main(wx.Frame):
def __init__(self):
wx.Frame.__init__(
self,
parent = None,
title = "Borges Infinite Image",
size = (600,300)
)
panel = wx.Panel(self)
notebook = wx.Notebook(panel)
explorer = explorer_panel(notebook)
notebook.AddPage(explorer, 'Explorer')
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(notebook, 1, wx.ALL|wx.EXPAND, 5)
panel.SetSizer(sizer)
if __name__ == "__main__":
app = wx.App()
frame = Main()
frame.Show()
import wx.lib.inspection as wxli
wxli.InspectionTool().Show()
app.MainLoop()
I'm trying to create a gui with the following layout:
Where the top panel is going to contain three figures, the three middle panels are going to contain textboxes and the bottom panel some buttons
Here is what I have so far:
import wx
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
from matplotlib.figure import Figure
from mpl_toolkits.mplot3d import Axes3D
import gui_functions as gf
class MainWindow(wx.Frame):
def __init__(self, parent, id, title = "Test GUI"):
wx.Frame.__init__(self, parent, wx.ID_ANY, title = "MyTitle", size=(1200,1000))
self.graphicsPanel = wx.Panel(self,-1,style=wx.CLIP_CHILDREN)
self.textPanel = wx.Panel(self)
self.buttonsPanel = wx.Panel(self)
self.graphicsPanel.figure = Figure()
self.graphicsPanel.canvas = FigureCanvas(self.graphicsPanel, -1, self.graphicsPanel.figure)
self.axeshandleA = self.graphicsPanel.figure.add_subplot(131, projection='3d',facecolor='#f3f3f3')
self.axeshandleB = self.graphicsPanel.figure.add_subplot(132, projection='3d',facecolor='#f3f3f3')
self.axeshandleC = self.graphicsPanel.figure.add_subplot(133, projection='3d',facecolor='#f3f3f3')
if __name__ == '__main__':
app = wx.App(False)
app.frame = MainWindow(None, wx.ID_ANY)
app.frame.Show()
app.MainLoop()
I've assumed that I need to start with three panels, that I somehow have to align vertically.
I'm thinking in the middle panel I will then need to add three additional panels and align them horizontally
My brain is thinking along the lines of how to structure div boxes in HTML and CSS.
My first problem is that I can't work out how to get the panels to a) fill the parent and b) align vertically.
Secondly, I'm working Spyder. Why do I have to start a new console after every call to the gui? If I don't then I get the error
The wx.App object must be created first!
I would really appreciate any help, because I'm stuck! Many thanks
I'm running wxPython 4.0.0rc1.dev3617+346e3b7 and Python 3.5.4
After much work and phaffing I now have this GUI:
The buttons are still wider than I would like, but I can't figure out how to make them narrower.
The code I have used is
import wx
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
from matplotlib.figure import Figure
from mpl_toolkits.mplot3d import Axes3D
class MainWindow(wx.Frame):
def __init__(self, parent, id, title = "Test GUI"):
wx.Frame.__init__(self, parent, wx.ID_ANY, title = "MyTitle", size=(1200,1000))
self.graphicsPanel = wx.Panel(self,-1,style=wx.CLIP_CHILDREN)
self.graphicsPanel.SetBackgroundColour('#3aafbb')
self.textPanel = wx.Panel(self)
self.textPanel.SetBackgroundColour('#ffaf33')
self.buttonsPanel = wx.Panel(self)
self.buttonsPanel.SetBackgroundColour('#489e3e')
self.graphicsPanel.figure = Figure()
self.graphicsPanel.canvas = FigureCanvas(self.graphicsPanel, 1, self.graphicsPanel.figure)
main_sizer = wx.BoxSizer(wx.VERTICAL)
main_sizer.Add(self.graphicsPanel, 3, wx.EXPAND, border = 20)
main_sizer.Add(self.textPanel, 6, wx.EXPAND, border = 20)
main_sizer.Add(self.buttonsPanel, 1, wx.EXPAND, border = 20)
self.SetSizer(main_sizer)
self.Maximize(True)
self.axeshandleA = self.graphicsPanel.figure.add_subplot(131, projection='3d',facecolor='#f3f3f3')
self.axeshandleB = self.graphicsPanel.figure.add_subplot(132, projection='3d',facecolor='#f3f3f3')
self.axeshandleC = self.graphicsPanel.figure.add_subplot(133, projection='3d',facecolor='#f3f3f3')
self.graphicsPanel_sizer = wx.BoxSizer()
self.graphicsPanel_sizer.Add(self.graphicsPanel.canvas, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.TOP|wx.BOTTOM, border=10)
self.graphicsPanel.SetSizerAndFit(self.graphicsPanel_sizer)
self.textPanelR = wx.Panel(self.textPanel)
self.textPanelR.SetBackgroundColour('#f2c4f5')
self.textPanelA = wx.Panel(self.textPanel)
self.textPanelA.SetBackgroundColour('#86478a')
self.textPanelC = wx.Panel(self.textPanel)
self.textPanelC.SetBackgroundColour('#e11fee')
self.textPanel_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.textPanel_sizer.Add(self.textPanelR, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.TOP|wx.BOTTOM, border=20)
self.textPanel_sizer.Add(self.textPanelA, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.TOP|wx.BOTTOM, border=20)
self.textPanel_sizer.Add(self.textPanelC, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.TOP|wx.BOTTOM, border=20)
self.textPanel.SetSizerAndFit(self.textPanel_sizer)
self.backBtn = wx.Button(self.buttonsPanel,label='<<BACK',style=wx.BU_EXACTFIT, size=(50,30))
self.backBtn.Bind(wx.EVT_BUTTON, self.backBtnClicked)
self.exitBtn = wx.Button(self.buttonsPanel,label='EXIT',style=wx.BU_EXACTFIT, size=(50,30))
self.exitBtn.Bind(wx.EVT_BUTTON, self.exitBtnClicked)
self.nextBtn = wx.Button(self.buttonsPanel,label='NEXT>>',style=wx.BU_EXACTFIT, size=(50,30))
self.nextBtn.Bind(wx.EVT_BUTTON, self.nextBtnClicked)
self.buttonsPanel_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.buttonsPanel_sizer.Add(self.backBtn, 1, wx.CENTER|wx.LEFT|wx.RIGHT, border=20)
self.buttonsPanel_sizer.Add(self.exitBtn, 1, wx.CENTER|wx.LEFT|wx.RIGHT, border=20)
self.buttonsPanel_sizer.Add(self.nextBtn, 1, wx.CENTER|wx.LEFT|wx.RIGHT, border=20)
self.buttonsPanel.SetSizer(self.buttonsPanel_sizer)
def backBtnClicked(self, event):
print("Back Button")
def nextBtnClicked(self, event):
print("Next Button")
def exitBtnClicked(self, event):
print("Exit Button")
if __name__ == '__main__':
app = wx.App(False)
app.frame = MainWindow(None, wx.ID_ANY)
app.frame.Show()
app.MainLoop()
I doubt it's as efficient as it could be, but it seems to mostly do what I want it to. Any further advice or recommendations would be gratefully received.
In a wxPython application I have an embedded a FigureCanvas with a matplotlib figure. I want to be able to switch the figure by loading a new one. However, the figure is not being updated.
Answers to similar topics suggests that panel.canvas.draw() and panel.Refresh() should do the trick, but I've also tried panel.Update() and panel.canvas.Refresh(). I fear that this only works if you want to redraw the canvas with the same figure?
So my question is: how do you replace the figure inside a canvas and make it update?
Below is a small (non-working) example. First a figure is loaded with a single axis. If you from the embedded shell type panel.LoadFigure() a new figure with 2x2 subplots is created and put into the canvas. But the new figure is not shown.
import numpy as np
import wx
from wx.py.shell import Shell
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
import matplotlib.pyplot as plt
class ShellPanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.shell = Shell(self)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.shell, 1, wx.GROW)
self.SetSizer(self.sizer)
self.Layout()
self.Fit()
class FigurePanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.parent = parent
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.figure, ax = plt.subplots()
self.canvas = FigureCanvas(self, -1, self.figure)
self.shellpanel = ShellPanel(self)
s1 = wx.BoxSizer(wx.VERTICAL)
s1.Add(self.canvas, 0, wx.GROW)
s1.Add(self.shellpanel, 1 , wx.EXPAND)
self.sizer.Add(s1, 5, wx.GROW)
self.SetSizer(self.sizer)
self.Layout()
self.Fit()
def LoadFigure(self):
self.figure, ax = plt.subplots(2, 2)
self.canvas.draw()
self.Refresh()
class FigureFrame(wx.Frame):
def __init__(self, parent, id, title, size):
wx.Frame.__init__(self, parent, id, title, size=size)
if __name__ == "__main__":
app = wx.App(False)
fr = FigureFrame(None, -1, title='Figure Loader', size=(wx.DisplaySize()[0]/2, wx.DisplaySize()[1]*3/4))
panel = FigurePanel(fr)
fr.Show()
app.MainLoop()
Is there any reason you are trying to create a new Figure and not simply new Axes on the already defined Figure?
I would write your code like so:
def LoadFigure(self):
self.figure.clf() # clear current figure
# add arbitrary number of new Axes
self.figure.add_subplot(221)
self.figure.add_subplot(222)
self.figure.add_subplot(223)
self.figure.add_subplot(224)
self.canvas.draw() # refresh canvas
EDIT: following your comment, I think the problem is that you're creating a new figure, but your Canvas is still referencing the old one. I don't know if you can change that directly in the FigureCanvas properties, maybe someone with more experience can provide a better answer. For the moment, I would Destroy the previous canvas, and create a new FigureCanvas object with your new figure.
def LoadFigure(self):
self.figure, ax = plt.subplots(2, 2)
self.canvas.Destroy()
self.canvas = FigureCanvas(self, -1, self.figure)
self.canvas.draw()
Try using the Figure itself to make your figure, not pyplot. It has usually worked for me because it gives you more room to improvise.
#!/usr/bin/python
# -*- coding: utf-8 -*-
import numpy as np
import wx
from wx.py.shell import Shell
from matplotlib.figure import Figure
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
import matplotlib.pyplot as plt
class ShellPanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.shell = Shell(self)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.shell, 1, wx.GROW)
self.SetSizer(self.sizer)
self.Layout()
self.Fit()
class FigurePanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.parent = parent
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.figure = Figure(figsize = (8,6.1), dpi =60)
self.ax = self.figure.add_subplot(1,1,1)
self.enlarged_figure = Figure(figsize = (8,6.1), dpi = 100)
self.ax2 = self.enlarged_figure.add_subplot(2,1,2)
self.canvas = FigureCanvas(self, -1, self.figure)
self.canvas.Show()
self.enlarged_canvas = FigureCanvas(self,-1,self.enlarged_figure)
self.enlarged_canvas.Show()
self.shellpanel = ShellPanel(self)
s1 = wx.BoxSizer(wx.VERTICAL)
s1.Add(self.canvas, 0, wx.GROW)
s1.Add(self.shellpanel, 1 , wx.EXPAND)
self.sizer.Add(s1, 5, wx.GROW)
self.SetSizer(self.sizer)
self.Layout()
self.Fit()
def LoadFigure(self):
self.figure, ax = plt.subplots(2, 2)
self.canvas.draw()
self.Refresh()
class FigureFrame(wx.Frame):
def __init__(self, parent, id, title, size):
wx.Frame.__init__(self, parent, id, title, size=size)
if __name__ == "__main__":
app = wx.App(False)
fr = FigureFrame(None, -1, title='Figure Loader', size=(wx.DisplaySize()[0]/2, wx.DisplaySize()[1]*3/4))
panel = FigurePanel(fr)
fr.Show()
app.MainLoop()
In the shell type in 'panel.LoadFigure()' and the new figure will show up very quickly and then disappear. Then type 'panel.canvas.draw()' and the new figure will be there. Then type 'panel.LoadFigure()' to load the old figure back. Repeat.
I don't know why the figure remains hidden after the MainLoop() continues but this is sort of a quick fix to your problem.
This python program plots a figure in a wxpython window.
How can I change the program so that:
the figure resizes when I resize the window
the main window cannot be resized smaller than a particular dimension? (say, half the default size of the window)
.
# adapted from:
# http://wiki.wxpython.org/Getting%20Started
# http://www.cs.colorado.edu/~kena/classes/5448/s11/presentations/pearse.pdf
import wx
import pylab as pl
import matplotlib
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
class GUIPanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.parent = parent
# create some sizers
sizer = wx.BoxSizer(wx.VERTICAL)
# A button
self.button =wx.Button(self, label="Tada!")
self.Bind(wx.EVT_BUTTON, self.OnClick,self.button)
# put up a figure
self.figure = pl.figure()
self.axes = self.drawplot(self.figure)
self.canvas = FigureCanvas(self, -1, self.figure)
sizer.Add(self.canvas, 0, wx.ALIGN_CENTER|wx.ALL)
sizer.Add(self.button, 0, wx.ALIGN_CENTER|wx.ALL)
self.SetSizerAndFit(sizer)
def log(self, fmt, *args):
print (fmt % args)
def OnClick(self,event):
self.log("button clicked, id#%d\n", event.GetId())
def drawplot(self, fig):
ax = fig.add_subplot(1,1,1)
t = pl.arange(0,1,0.001)
ax.plot(t,t*t)
ax.grid()
return ax
app = wx.App(False)
frame = wx.Frame(None)
panel = GUIPanel(frame)
frame.Fit()
frame.Center()
frame.Show()
app.MainLoop()
1) Modify the way you setup your sizer to this:
sizer.Add(self.canvas, 1, wx.EXPAND | wx.ALL)
Here is method reference. It is also helpful to install and use wxPython Demo. Sizers are covered nicely there. BTW: wx.ALL is useless unless you specify border.
2) And add this to your frame setup after frame.Show():
size = frame.GetSize()
frame.SetMinSize((size[0] / 2, size[1] / 2))
This python program plots a figure in a wxpython window. It runs fine in Enthought Python Distribution 7.3-2, but when I close the figure, python keeps running and doesn't exit.
What am I missing? When I create wxpython GUIs that don't use matplotlib, they exit correctly after I close the window. I guess there must be something about message loops in wxpython that I don't understand.
# adapted from:
# http://wiki.wxpython.org/Getting%20Started
# http://www.cs.colorado.edu/~kena/classes/5448/s11/presentations/pearse.pdf
import wx
import pylab as pl
import matplotlib
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
class GUIPanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.parent = parent
# create some sizers
sizer = wx.BoxSizer(wx.VERTICAL)
# A button
self.button =wx.Button(self, label="Tada!")
self.Bind(wx.EVT_BUTTON, self.OnClick,self.button)
# put up a figure
self.figure = pl.figure()
self.axes = self.drawplot(self.figure)
self.canvas = FigureCanvas(self, -1, self.figure)
sizer.Add(self.canvas, 0, wx.ALIGN_CENTER|wx.ALL)
sizer.Add(self.button, 0, wx.ALIGN_CENTER|wx.ALL)
self.SetSizerAndFit(sizer)
def log(self, fmt, *args):
print (fmt % args)
def OnClick(self,event):
self.log("button clicked, id#%d\n", event.GetId())
def drawplot(self, fig):
ax = fig.add_subplot(1,1,1)
t = pl.arange(0,1,0.001)
ax.plot(t,t*t)
ax.grid()
return ax
app = wx.App(False)
frame = wx.Frame(None)
panel = GUIPanel(frame)
frame.Fit()
frame.Center()
frame.Show()
app.MainLoop()
Huh. Per the discussion in comments from tcaswell, I changed
self.figure = pl.figure()
to
self.figure = matplotlib.figure.Figure()
and it fixed the problem. (python exits when I close the window)