class wxMatplotPanelSimple( wx.Panel ):
def __init__( self, renderPanel, color=None, dpi=None, **kwargs ):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
# initialize Panel
if 'id' not in list(kwargs.keys()):
kwargs['id'] = wx.ID_ANY
if 'style' not in list(kwargs.keys()):
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__( self, renderPanel, **kwargs )
self.figure = Figure( None, dpi )
#self.canvas = NoRepaintCanvas( self, -1, self.figure )
self.canvas = FigureCanvasWxAgg( self, -1, self.figure )
sizer = wx.BoxSizer();
sizer.Add( self.canvas, 1, wx.EXPAND )
self.SetSizer( sizer )
self.axes = self.figure.add_subplot( 111 )
self.axes.set_aspect( 'auto' )
self.Bind(wx.EVT_SIZE, self._onSize)
def _onSize( self, event = None ):
pixels = tuple( [ self.GetSize()[0], self.GetSize()[1] ] )
print(pixels)
#if self.canvas.GetMinSize( )[0] != pixels[0] or \
#self.canvas.GetMinSize( )[1] != pixels[1] :
self.canvas.SetMinSize( pixels )
self.figure.set_size_inches( float( pixels[ 0 ] )/self.figure.get_dpi(),
float( pixels[ 1 ] )/self.figure.get_dpi() )
self.canvas.draw()
class PlotPanel(wx.Panel):
"""The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event."""
def __init__(self, parent, color=None, dpi=None, **kwargs):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
self.parent = parent
# initialize Panel
if 'id' not in kwargs.keys():
kwargs['id'] = wx.ID_ANY
if 'style' not in kwargs.keys():
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__(self, parent, **kwargs)
# initialize matplotlib stuff
self.figure = Figure(None, dpi)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.SetColor(color)
self._SetSize()
self.initial_draw()
self._resizeflag = False
self._redrawflag = False
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def SetColor(self, rgbtuple=None):
"""Set figure and canvas colours to be the same."""
if rgbtuple is None:
rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get()
clr = [c/255. for c in rgbtuple]
self.figure.set_facecolor(clr)
self.figure.set_edgecolor(clr)
self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple))
def _onSize(self, event):
self._resizeflag = True
def _onIdle(self, evt):
with draw_lock:
if self._resizeflag:
self._resizeflag = False
self._SetSize()
if self._redrawflag:
self._redrawflag = False
self.canvas.draw()
def _SetSize(self):
# When drawing from another thread, I think this may need a lock
pixels = tuple(self.parent.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(),
float(pixels[1])/self.figure.get_dpi())
def initial_draw(self): pass # abstract, to be overridden by child classes
def segmented_image(arr):
"""Get segmented image as a numpy array"""
colors_dic = {'0':'#ffd300', '1':'#93cc93', '2':'#4970a3', '3':'#999999'}
keys = list(np.unique(arr))
keys = [str(i) for i in keys]
colors = [colors_dic.get(key) for key in keys]
cmap = mpl.colors.ListedColormap(colors)
fig = Figure()
fig.set_size_inches(256/fig.get_dpi(), 256/fig.get_dpi())
fig.subplots_adjust(0,0,1,1)
canvas = FigureCanvas(fig)
ax = fig.gca()
plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0,
hspace = 0, wspace = 0)
ax.imshow(arr, cmap=cmap)
ax.axis('off')
ax.margins(0,0)
canvas.draw() # draw the canvas, cache the renderer
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)
return image
class MatplotlibPanel(wx.Panel):
def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)):
self.parent = parent
#(0) Initialize panel:
wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label)
self.SetMinSize(size)
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8,)*3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes)
self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes)
def _create_axes(self):
self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple( self.GetClientSize() )
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi()
self.figure.set_size_inches( szInches[0] , szInches[1] )
def callback_enter_axes(self, event):
self.parent.parent.panel_enter(event, panel=self.parent)
def callback_leave_axes(self, event):
self.parent.parent.panel_leave(event)
def cla(self):
self.ax.cla()
self.ax.set_position([0,0,1,1])
self.ax.set_axis_bgcolor([0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I0, I, cmax=None, pois=None):
if I!=None:
if cmax==None:
cmax = I.max()
I[I==0] = np.nan
self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax)
self.ax.contour(I0>0, 1, colors="0.5", linewidths=1)
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05]*3)
self.ax.axis('image')
if pois!=None:
for i,(x,y) in enumerate(pois):
self.ax.plot(x, y, 'wo', markersize=8)
self.ax.text(x+1, y+1, '%d'%(i+1), bbox=dict(facecolor='w'))
self.canvas.draw()
class MatplotlibPanel(wx.Panel):
def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)):
self.parent = parent
#(0) Initialize panel:
wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label)
self.SetMinSize(size)
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8,)*3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes)
self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes)
self.Bind(wx.EVT_ENTER_WINDOW, self.callback_enter_axes)
self.Bind(wx.EVT_LEAVE_WINDOW, self.callback_leave_axes)
def _create_axes(self):
self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple( self.GetClientSize() )
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi()
self.figure.set_size_inches( szInches[0] , szInches[1] )
def callback_enter_axes(self, event):
self.parent.parent.panel_enter(event, panel=self.parent)
def callback_leave_axes(self, event):
self.parent.parent.panel_leave(event)
def cla(self):
self.ax.cla()
self.ax.set_position([0,0,1,1])
self.ax.set_axis_bgcolor([0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I, cmax=None):
if I!=None:
if cmax==None:
cmax = I.max()
I[I==0] = np.nan
self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax)
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05]*3)
self.ax.axis('image')
self.canvas.draw()
class myWxPlot(wx.Panel):
def __init__( self, parent):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
self.parent = parent
wx.Panel.__init__( self, parent)
#matplotlib figure
self.figure = Figure( None )
self.figure.set_facecolor( (0.7,0.7,1.) )
self.subplot = self.figure.add_subplot( 111 )
#canvas
self.canvas = FigureCanvasWxAgg( self, -1, self.figure )
self.canvas.SetBackgroundColour( wx.Colour( 100,255,255 ) )
self._SetSize()
self.draw2()
def _SetSize( self ):
size = tuple( self.parent.GetClientSize() )
self.SetSize( size )
self.canvas.SetSize( size )
self.figure.set_size_inches( float( size[0] )/self.figure.get_dpi(),
float( size[1] )/self.figure.get_dpi() )
def draw(self):
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
x = np.arange(-3, 3, 0.25)
y = np.arange(-3, 3, 0.25)
X, Y = np.meshgrid(x, y)
Z = np.sin(X)+ np.cos(Y)
ax = Axes3D(self.figure)
ax.plot_wireframe(X,Y,Z)
def draw2(self):
import numpy as np
theta = np.arange(0,200, 0.1)
x = 2*np.cos(theta/7)
y = 3*np.sin(theta/3)
self.subplot.plot(x,y, '-r')
self.subplot.set_title("Sample", fontsize = 12)
self.subplot.set_xlabel("x")
self.subplot.set_ylabel("y")
self.subplot.set_xlim([-4, 4])
self.subplot.set_ylim([-4, 4])
class MatplotlibPanel(wx.Panel):
def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)):
self.parent = parent
#(0) Initialize panel:
wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label)
self.SetMinSize(size)
self.parent = parent
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8,)*3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes)
self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes)
#self.Bind(wx.EVT_ENTER_WINDOW, self.callback_enter_axes)
self.Bind(wx.EVT_LEAVE_WINDOW, self.callback_leave_axes)
def _create_axes(self):
self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple( self.GetClientSize() )
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi()
self.figure.set_size_inches( szInches[0] , szInches[1] )
def callback_enter_axes(self, event):
self.parent.parent.panel_enter(event, panel=self.parent)
def callback_leave_axes(self, event):
self.parent.parent.panel_leave(event)
def cla(self):
self.ax.cla()
self.ax.set_position([0,0,1,1])
self.ax.set_axis_bgcolor([0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I, cmax=None):
if I!=None:
if cmax==None:
cmax = I.max()
I[I==0] = np.nan
self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax)
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05]*3)
self.ax.axis('image')
self.canvas.draw()
class IdentifyMatplotlibPanel(wx.Panel):
def __init__(self,
parent,
ID=-1,
label="",
pos=wx.DefaultPosition,
size=(100, 25)):
#(0) Initialize panel:
wx.Panel.__init__(self, parent, ID, pos, size, wx.STATIC_BORDER, label)
self.SetMinSize(size)
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8, ) * 3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
def _create_axes(self):
self.ax = self.figure.add_axes((0, 0, 1, 1), axisbg=[0.5] * 3)
# self.plot(None)
# self.ax.plot( np.random.randn(10) )
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple(self.GetClientSize())
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0]) / self.figure.get_dpi(), float(
szPixels[1]) / self.figure.get_dpi()
self.figure.set_size_inches(szInches[0], szInches[1])
def cla(self):
self.ax.cla()
self.ax.set_position([0, 0, 1, 1])
self.ax.set_axis_bgcolor([0.5] * 3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0, 1), ylim=(0, 1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I, cmax=None):
if I != None:
if cmax == None:
cmax = I.max()
I[I == 0] = np.nan
self.ax.imshow(I,
interpolation='nearest',
origin='lower',
vmin=0,
vmax=cmax)
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05] * 3)
self.ax.axis('image')
self.canvas.draw()
class CheckMeansPanel(wx.Panel):
def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)):
#(0) Initialize panel:
wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label)
self.SetMinSize(size)
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8,)*3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
# self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes)
# self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes)
def _create_axes(self):
self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3)
self.cax = self.figure.add_axes((0.1,0.05,0.8,0.02), axisbg=[0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple( self.GetClientSize() )
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi()
self.figure.set_size_inches( szInches[0] , szInches[1] )
# def callback_enter_axes(self, event):
# print 'buta-san in'
# def callback_leave_axes(self, event):
# print 'buta-san out'
def cla(self):
self.ax.cla()
self.cax.cla()
# self.ax.set_position([0,0,1,1])
self.ax.set_axis_bgcolor([0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I):
I = np.asarray(I, dtype=float)
I[I==0] = np.nan
self.ax.imshow(I, interpolation='nearest', origin='lower')
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05]*3)
self.ax.axis('image')
cb = pyplot.colorbar(cax=self.cax, mappable=self.ax.images[0], orientation='horizontal')
pyplot.setp(cb.ax.get_xticklabels(), color='0.5')
self.canvas.draw()
class PanelPlot(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent, style=wx.WS_EX_PROCESS_IDLE)
''', style = wx.NO_FULL_REPAINT_ON_RESIZE'''
self.figure = Figure()
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.set_size()
self.draw()
self._resize_flag = False
#self.Bind(wx.EVT_IDLE, self.on_idle)
#self.Bind(wx.EVT_SIZE, self.on_size)
def on_idle(self, event):
#event.RequestMore()
if self._resize_flag:
self._resize_flag = False
#wx.CallLater(500,self.set_size())
def on_size(self, event):
self._resize_flag = True
def set_size(self):
pixels = tuple(self.GetSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(
[float(x) / self.figure.get_dpi() for x in pixels])
def draw(self):
self.canvas.draw()
def getPlotImage(data_x,
data_y,
cols,
title,
line_labels,
x_label,
y_label,
ylim=None,
legend=1):
cols = [(col[0] / 255.0, col[1] / 255.0, col[2] / 255.0) for col in cols]
fig = Figure(
# figsize=(6.4, 3.6), dpi=300,
figsize=(4.8, 2.7),
dpi=400,
# edgecolor='k',
# facecolor ='k'
)
# fig.tight_layout()
# fig.set_tight_layout(True)
fig.subplots_adjust(
bottom=0.17,
right=0.95,
)
canvas = FigureCanvas(fig)
ax = fig.gca()
n_data = len(data_y)
for i in range(n_data):
datum_y = data_y[i]
line_label = line_labels[i]
col = cols[i]
args = {'color': col}
if legend:
args['label'] = line_label
ax.plot(data_x, datum_y, **args)
plt.rcParams['axes.titlesize'] = 10
# fontdict = {'fontsize': plt.rcParams['axes.titlesize'],
# 'fontweight': plt.rcParams['axes.titleweight'],
# 'verticalalignment': 'baseline',
# 'horizontalalignment': plt.loc
# }
ax.set_title(title,
# fontdict=fontdict
)
if legend:
ax.legend(fancybox=True, framealpha=0.1)
ax.grid(1)
ax.set_xlabel(x_label)
ax.set_ylabel(y_label)
if ylim is not None:
ax.set_ylim(*ylim)
canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
plot_img = np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width), 3)
return plot_img
class wxMatplotPanelSimple(wx.Panel):
def __init__(self, renderPanel, color=None, dpi=None, **kwargs):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
# initialize Panel
if 'id' not in list(kwargs.keys()):
kwargs['id'] = wx.ID_ANY
if 'style' not in list(kwargs.keys()):
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__(self, renderPanel, **kwargs)
self.figure = Figure(None, dpi)
#self.canvas = NoRepaintCanvas( self, -1, self.figure )
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
sizer = wx.BoxSizer()
sizer.Add(self.canvas, 1, wx.EXPAND)
self.SetSizer(sizer)
self.axes = self.figure.add_subplot(111)
self.axes.set_aspect('auto')
self.Bind(wx.EVT_SIZE, self._onSize)
def _onSize(self, event=None):
pixels = tuple([self.GetSize()[0], self.GetSize()[1]])
print(pixels)
# if self.canvas.GetMinSize( )[0] != pixels[0] or \
# self.canvas.GetMinSize( )[1] != pixels[1] :
self.canvas.SetMinSize(pixels)
self.figure.set_size_inches(
float(pixels[0]) / self.figure.get_dpi(),
float(pixels[1]) / self.figure.get_dpi())
self.canvas.draw()
def visualize(feat, labels, epoch):
colors = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff',
'#ff00ff', '#990000', '#999900', '#009900', '#009999']
fig = Figure(figsize=(6, 6), dpi=100)
fig.clf()
canvas = FigureCanvas(fig)
ax = fig.gca()
feat = feat.data.cpu().numpy()
labels = labels.data.cpu().numpy()
for i in range(10):
ax.scatter(feat[labels == i, 0], feat[labels == i, 1], c=colors[i], s=1)
ax.text(feat[labels == i, 0].mean(), feat[labels == i, 1].mean(), str(i), color='black', fontsize=12)
ax.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], loc='upper right')
ax.text(0, 0, "epoch=%d" % epoch)
canvas.draw()
if (os.path.exists(imgDir)):
pass
else:
os.makedirs(imgDir)
fig.savefig(imgDir + '/epoch=%d.jpg' % epoch)
width, height = fig.get_size_inches() * fig.get_dpi()
img = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)
tt = transforms.ToTensor()
timg = tt(img)
timg.unsqueeze(0)
writer.add_image('NormFace', timg, epoch)
def get_virtual_drone():
fig_scale = 1
fig = Figure(figsize=(4 * fig_scale, 3 * fig_scale), dpi=200)
canvas = FigureCanvas(fig)
ax = fig.gca(projection='3d')
ax.set_title("Drone Position (meters)")
ax.set_ylim([-0.7, 0.7])
ax.set_xlim([-0.7, 0.7])
ax.set_zlim([0, 1])
color = "#00ff00"
quiver_color = "#0055ff"
if d_pos != None:
ax.scatter([d_pos['x']], [d_pos['y']], [d_pos['z']], color=color)
if d_vel != None:
ax.quiver(d_pos['x'],
d_pos['y'],
d_pos['z'],
d_vel['x'],
d_vel['y'],
d_vel['z'],
length=0.2,
color=quiver_color)
canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width),
3)
return image
def plot_as_image(masking: "Masking") -> "Array":
"""
Plot layer wise density as bar plot figure.
:param masking: Masking instance
:type masking: sparselearning.core.Masking
:return: Numpy array representing figure (H, W, 3)
:rtype: np.ndarray
"""
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.gca()
density_ll = _get_density_ll(masking)
bin_ll = np.arange(len(density_ll)) + 1
width = 0.8
ax.bar(bin_ll, density_ll, width, color="b")
ax.set_ylabel("Density")
ax.set_xlabel("Layer Number")
canvas.draw() # draw the canvas, cache the renderer
width, height = fig.get_size_inches() * fig.get_dpi()
width, height = int(width), int(height)
image = np.fromstring(canvas.tostring_rgb(),
dtype="uint8").reshape(height, width, 3)
return image
def get_Img_Matrix_Antialiasing(point_pos, w, x_size=128, y_size=128):
point_pos = np.dot(w, point_pos)
mydpi = 96
fig = Figure(figsize=(x_size / mydpi, y_size / mydpi), dpi=mydpi)
fig.subplots_adjust(left=0.,
bottom=0.,
right=1.,
top=1.,
wspace=0,
hspace=0)
fig.set_facecolor('black')
a = fig.add_subplot(111, axisbg='r')
canvas = FigureCanvas(fig)
# ax = fig.gca()
a.axis([0, x_size, y_size, 0])
a.axis('off')
a.plot(point_pos[:, 0], point_pos[:, 1], c='w')
# fig.tight_layout()
# plt.tight_layout()
canvas.draw() # draw the canvas, cache the renderer
width, height = fig.get_size_inches() * fig.get_dpi()
# print(width, height)
image = np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width),
3)[:, :, 0]
return image
class PlotPlotPanel(wx.Panel):
def __init__(self, parent, dpi=None, **kwargs):
wx.Panel.__init__(self, parent, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, **kwargs)
self.ztv_frame = self.GetTopLevelParent()
self.figure = Figure(dpi=None, figsize=(1.,1.))
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.Bind(wx.EVT_SIZE, self._onSize)
self.axes_widget = AxesWidget(self.figure.gca())
self.axes_widget.connect_event('motion_notify_event', self.on_motion)
self.plot_point = None
def on_motion(self, evt):
if evt.xdata is not None:
xarg = np.abs(self.ztv_frame.plot_panel.plot_positions - evt.xdata).argmin()
ydata = self.ztv_frame.plot_panel.plot_im_values[xarg]
self.ztv_frame.plot_panel.cursor_position_textctrl.SetValue('{0:.6g},{1:.6g}'.format(evt.xdata, ydata))
if self.plot_point is None:
self.plot_point, = self.axes.plot([evt.xdata], [ydata], 'xm')
else:
self.plot_point.set_data([[evt.xdata], [ydata]])
self.figure.canvas.draw()
def _onSize(self, event):
self._SetSize()
def _SetSize(self):
pixels = tuple(self.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi())
def visualize_cos(feat, labels, epoch):
colors = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff',
'#ff00ff', '#990000', '#999900', '#009900', '#009999']
fig = Figure(figsize=(6, 6), dpi=100)
fig.clf()
canvas = FigureCanvas(fig)
ax = fig.gca()
feat = feat / feat.norm(2, 1).unsqueeze(1).repeat(1, 2)
feat = feat.data.cpu().numpy()
labels = labels.data.cpu().numpy()
weight = head.state_dict()['weight'].t()
weight = weight / weight.norm(2, 1).unsqueeze(1).repeat(1, 2)
weight = weight.data.cpu().numpy()
for i in range(10):
ax.scatter(feat[labels == i, 0], feat[labels == i, 1], c=colors[i], s=1)
ax.text(feat[labels == i, 0].mean(), feat[labels == i, 1].mean(), str(i), color='black', fontsize=12)
ax.plot([0,weight[i][0]],[0,weight[i][1]],linewidth=2,color=colors[i])
ax.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], loc='upper right')
ax.text(0, 0, "epoch=%d" % epoch)
canvas.draw()
fig.savefig(imgDir + '/cos_epoch=%d.jpg' % epoch)
width, height = fig.get_size_inches() * fig.get_dpi()
img = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)
tt = transforms.ToTensor()
timg = tt(img)
timg.unsqueeze(0)
writer.add_image('NormFace_cos', timg, epoch)
class Plot:
def __init__(self, size, pos, x_label, x, y_label, y, title):
self.x_series = x
self.x_label = x_label
self.y_label = y_label
self.y_series = y
self.title = title
self.size = size
self.pos = pos
self.fig = Figure()
self.figure = []
def draw(self, window):
canvas = FigureCanvas(self.fig)
ax = self.fig.gca()
ax.plot(self.x_series, self.y_series)
ax.set_xlabel(self.x_label)
ax.set_ylabel(self.y_label)
ax.set_title(self.title)
ax.grid(True)
canvas.draw() # draw the canvas, cache the renderer
width, height = self.fig.get_size_inches() * self.fig.get_dpi()
self.figure = np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(
int(height), int(width), 3)
self.figure = cv2.resize(self.figure, flip(self.size))
window[self.pos[0]:self.pos[0] + self.size[0],
self.pos[1]:self.pos[1] + self.size[1], :] = self.figure
def my_draw(self):
"""
This function is used by DQL_visualization_actions.py to make video from sequence of actions
"""
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.gca()
ax.imshow(self.image_playground)
rect = patches.Rectangle((self.agent_window[0], self.agent_window[1]),
self.agent_window[2] - self.agent_window[0],
self.agent_window[3] - self.agent_window[1],
linewidth=1,
edgecolor='r',
facecolor='none')
ax.add_patch(rect)
for target in [self.targets[0]]:
rect2 = patches.Rectangle((target[0], target[1]),
target[2] - target[0],
target[3] - target[1],
linewidth=1,
edgecolor='b',
facecolor='none')
ax.add_patch(rect2)
canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
return np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width), 3)
def my_draw(self):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.gca()
ax.imshow(self.image_playground)
# Drawing agent window
rect = patches.Rectangle((self.agent_window[0], self.agent_window[1]),
self.agent_window[2] - self.agent_window[0],
self.agent_window[3] - self.agent_window[1],
linewidth=1,
edgecolor='r',
facecolor='none')
ax.add_patch(rect)
# Drawing target objects bouning boxes
for target in [self.targets[0]]:
rect2 = patches.Rectangle((target[0], target[1]),
target[2] - target[0],
target[3] - target[1],
linewidth=1,
edgecolor='b',
facecolor='none')
ax.add_patch(rect2)
canvas.draw() # draw the canvas, cache the renderer
width, height = fig.get_size_inches() * fig.get_dpi()
return np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width), 3)
def __init__(self, figure=None, logger=None, width=500, height=500):
Callback.Callbacks.__init__(self)
if figure is None:
figure = Figure()
dpi = figure.get_dpi()
if dpi is None or dpi < 0.1:
dpi = 100
wd_in, ht_in = float(width)/dpi, float(height)/dpi
figure.set_size_inches(wd_in, ht_in)
self.fig = figure
if hasattr(self.fig, 'set_tight_layout'):
self.fig.set_tight_layout(True)
self.logger = logger
self.fontsize = 10
self.ax = None
self.logx = False
self.logy = False
self.xdata = []
self.ydata = []
# For callbacks
for name in ('draw-canvas', ):
self.enable_callback(name)
def __init__(self, figure: Figure):
"""Initialize window."""
super(FigureWindow,
self).__init__(size=figure.get_size_inches() * figure.get_dpi())
chart = Chart()
self.content = toga.Box(children=[chart])
chart.draw(figure)
class PlotPanel(XmlPanel):
"""Draw a plot (graph)"""
def __init__(self, parent,elem):
XmlPanel.__init__(self, parent)
self.border = True
self.elem = elem
self.figure = Figure()
self.applySize()
self.plot = FigureCanvas(self,-1,self.figure) # FancyText(self,"hi")
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.plot, 1, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.Fit()
self.render()
def applySize(self):
size = self.elem.attrib.get("size",None)
if size:
psize = self.parent.GetSize()
try:
size = literal_eval(size)
size = (min(psize[0],size[0]), min(psize[1],size[1])) # graph can't be bigger than the xmlterm
self.SetInitialSize(size)
self.SetSize(size)
dpi = self.figure.get_dpi()
self.figure.set_size_inches(float(size[0])/dpi,float(size[1])/dpi)
# self.plot.SetSize(size)
self.Fit()
except ValueError,e: # size is malformed
print "bad size"
pass
return size
return None
class matplotPanel(wx.Panel):
def __init__(self, drawfunc, parent, id, *args, **kwargs):
super(matplotPanel, self).__init__(parent, id, *args, **kwargs)
self.drawfunc = drawfunc
self.parent = parent
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_PAINT, self.OnPaint)
def _SetSize(self):
# size = tuple(self.parent.GetClientSize())
size = tuple(self.GetClientSize())
# self.SetSize(size)
self.figure = Figure(None)
self.canvas = FigureCanvasWxAgg(self, wx.NewId(), self.figure)
self.canvas.SetSize(size)
dpi = self.figure.get_dpi()
self.figure.set_size_inches(float(size[0]) / dpi, float(size[1]) / dpi)
def OnSize(self, ev):
self.Refresh()
def OnPaint(self, ev):
self._SetSize()
dc = wx.PaintDC(self) # don't delete this line
self.drawfunc(self)
def set_title(fig: Figure, ax: Axes, title: str, digital: bool):
"""Sets the title for the given axes to the given value. This is more
particular than the default matplotlib Axes.set_title.
:param Figure fig: the figure the axes is in
:param Axes ax: the axes which you want to have a title
:param str title: the desired title text
:param bool digital: if True, a large font size is selected. Otherwise,
a smaller font size is selected
:returns: TextCollection that was added
"""
figw = fig.get_figwidth()
figh = fig.get_figheight()
figw_px = figw * fig.get_dpi()
pad = max(int(0.3125 * figh), 1)
font_size = int((8 / 1.92) * figw) if digital else int((4 / 1.92) * figw)
font_size = max(5, font_size)
axtitle = ax.set_title(title, pad=pad)
axtitle.set_fontsize(font_size)
renderer = fig.canvas.get_renderer()
bb = axtitle.get_window_extent(renderer=renderer)
while bb.width >= (figw_px - 26) * 0.9 and font_size > 9:
font_size = max(5, font_size - 5)
axtitle.set_fontsize(font_size)
bb = axtitle.get_window_extent(renderer=renderer)
return axtitle
class PlotPanel(wx.Panel):
"""
The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event.
"""
def __init__(self, parent, obj_id):
# initialize Panel
wx.Panel.__init__(self, parent, obj_id)
# initialize matplotlib stuff
self.figure = Figure(None, None)
self.canvas = FigureCanvasWxAgg(self, wx.ID_ANY, self.figure)
rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get()
clr = [c / 255.0 for c in rgbtuple]
self.figure.set_facecolor(clr)
self.figure.set_edgecolor(clr)
self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple))
self.Bind(wx.EVT_SIZE, self._on_size)
def _on_size(self, event):
self._set_size()
def _set_size(self):
pixels = tuple(self.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(float(pixels[0]) / self.figure.get_dpi(), float(pixels[1]) / self.figure.get_dpi())
def draw(self):
pass # abstract, to be overridden by child classes
class PlotPanel(wx.Panel):
"""
The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event.
"""
def __init__(self, parent, obj_id):
# initialize Panel
wx.Panel.__init__(self, parent, obj_id)
# initialize matplotlib stuff
self.figure = Figure(None, None)
self.canvas = FigureCanvasWxAgg(self, wx.ID_ANY, self.figure)
rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get()
clr = [c / 255. for c in rgbtuple]
self.figure.set_facecolor(clr)
self.figure.set_edgecolor(clr)
self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple))
self.Bind(wx.EVT_SIZE, self._on_size)
def _on_size(self, event):
self._set_size()
def _set_size(self):
pixels = tuple(self.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(
float(pixels[0]) / self.figure.get_dpi(),
float(pixels[1]) / self.figure.get_dpi())
def draw(self):
pass # abstract, to be overridden by child classes
class Render(object):
def __init__(self, figsize=(15, 15), dpi=48):
self.figsize = figsize
self.dpi = dpi
self.fig = Figure(figsize=figsize, dpi=dpi)
self.canvas = FigureCanvas(self.fig)
self.artists = []
def add_artist(self, artist):
self.artists.append(artist)
def new_frame(self):
self.fig.clear()
self.ax = self.fig.gca()
self.ax.clear()
for artist in self.artists:
artist.remove()
self.artists = []
self.ax.set_xlim(-0.1, MAP_SIZE + 1.1)
self.ax.set_ylim(-0.1, MAP_SIZE + 1.1)
self.ax.axis('off')
def draw(self):
for artist in self.artists:
self.ax.add_artist(artist)
self.canvas.draw() # draw the canvas, cache the renderer
width, height = self.fig.get_size_inches() * self.fig.get_dpi()
image = np.frombuffer(self.canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)
return image
class PlotPanel (wx.Panel):
"""The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event."""
def __init__( self, parent, **kwargs ):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
# initialize Panel
if 'id' not in kwargs.keys():
kwargs['id'] = wx.ID_ANY
if 'style' not in kwargs.keys():
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__( self, parent, **kwargs )
# initialize matplotlib stuff
self.figure = Figure()
self.canvas = FigureCanvasWxAgg( self, -1, self.figure )
self._SetSize()
self.draw()
#self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def _onSize( self, event ):
self._SetSize()
def _SetSize( self ):
pixels = tuple( self.parent.GetClientSize() )
self.SetSize( pixels )
self.canvas.SetSize( pixels )
self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(),
float( pixels[1] )/self.figure.get_dpi() )
def draw(self): pass # abstract, to be overridden by child classes
class PlotPanel (wx.Panel):
"""
PlotPanel class taken from http://www.scipy.org/Matplotlib_figure_in_a_wx_panel
The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event."""
def __init__(self, parent, color=None, dpi=None, **kwargs):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
self.parent = parent
# initialize Panel
if 'id' not in list(kwargs.keys()):
kwargs['id'] = wx.ID_ANY
if 'style' not in list(kwargs.keys()):
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__(self, parent, **kwargs)
# initialize matplotlib stuff
self.figure = Figure(None, dpi)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.SetColor(color)
self._SetSize()
self.draw()
self._resizeflag = False
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def SetColor(self, rgbtuple=None):
"""Set figure and canvas colours to be the same."""
if rgbtuple is None:
rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get()
clr = [c / 255. for c in rgbtuple]
self.figure.set_facecolor(clr)
self.figure.set_edgecolor(clr)
self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple))
def _onSize(self, event):
self._resizeflag = True
def _onIdle(self, evt):
if self._resizeflag:
self._resizeflag = False
self._SetSize()
def _SetSize(self):
pixels = tuple(self.parent.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(float(pixels[0]) / self.figure.get_dpi(),
float(pixels[1]) / self.figure.get_dpi())
def draw(self):
# abstract, to be overridden by child classes
raise NotImplementedError(
"Abstract method - must be defined in subclass")
class GraphFrame(tk.Frame):
def __init__(self, root, **kw):
self.root = root
tk.Frame.__init__(self, self.root, kw)
# создание полей под объекты GUI
self.frame, self.f_1, self.ax0, self.label_font, self.f_1_canvas = None, None, None, None, None
self.pause_button = None
self.data, self.legend = [["Имя 0", [1, 2, 3], "Name 0"]], None
self.table = None
self._show_time = 1000
self.show_time_var, self.show_time_label, self.show_time_entry = None, None, None
self.gui_set()
self.x_label = "Напряжение ЗС, В"
self.y_label = "Ток МПЗ, А"
def gui_set(self):
# graph
self.frame = tk.Frame(self, bg="gray10")
self.frame.place(x=10, y=10, relwidth=1, relheight=1, width=-20, height=-40)
self.f_1 = Figure(figsize=(6.5, 5.5), dpi=100, facecolor="#A9A9A9", frameon=True)
self.ax0 = self.f_1.add_axes((0.1, 0.15, 0.88, 0.83), facecolor="#D3D3D3", frameon=True, yscale="linear")
self.label_font = {'family': 'Arial',
'color': 'Black',
'weight': 'normal',
'size': 12,
}
self.f_1_canvas = FigureCanvasTkAgg(self.f_1, master=self.frame)
self.f_1_canvas.get_tk_widget().pack(fill="both", expand=1)
self.f_1_canvas.draw()
self.resize()
toolbar = NavigationToolbar2Tk(self.f_1_canvas, self)
toolbar.place(x=0, rely=1, y=-35)
toolbar.update()
def resize(self):
self.frame.update_idletasks()
dx = self.frame.winfo_width()
dy = self.frame.winfo_height()
if dx > 1 and dx > 1:
try:
frame_info = self.frame.place_info()
dpi = self.f_1.get_dpi()
f_1_height = (float(frame_info["relheight"]) * dy + float(frame_info["height"])) / dpi
f_1_width = (float(frame_info["relwidth"]) * dx + float(frame_info["width"])) / dpi
self.f_1.set_size_inches(f_1_width, f_1_height)
except:
pass
self.f_1_canvas.show()
# self.f_1_canvas.get_tk_widget().pack(fill="both", expand=1)
pass
def plot(self, *arg, **kw):
self.ax0.cla()
self.ax0.plot(*arg, **kw)
self.ax0.set_xlabel(self.x_label)
self.ax0.set_ylabel(self.y_label)
self.ax0.grid(which="both")
self.f_1_canvas.draw()
pass
class PlotPanel(wx.Panel):
"""The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event."""
def __init__(self, parent, color=None, dpi=None, **kwargs):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
# initialize Panel
if 'id' not in kwargs.keys():
kwargs['id'] = wx.ID_ANY
if 'style' not in kwargs.keys():
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__(self, parent, **kwargs)
# initialize matplotlib stuff
self.figure = Figure(None, dpi)
self.axes = self.figure.gca()
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.SetColor(color)
self._SetSize()
self.draw()
self.axes.set_xlabel('T (s)')
self.axes.set_ylabel('Alfa_max (g)')
self.axes.set_title("wave curve")
self.axes.grid(True)
self._resizeflag = False
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def SetColor(self, rgbtuple=None):
"""Set figure and canvas colours to be the same."""
if rgbtuple is None:
rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get()
clr = [c / 255. for c in rgbtuple]
self.figure.set_facecolor(clr)
self.figure.set_edgecolor(clr)
self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple))
def _onSize(self, event):
self._resizeflag = True
def _onIdle(self, evt):
if self._resizeflag:
self._resizeflag = False
self._SetSize()
def _SetSize(self):
pixels = tuple(self.parent.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(
float(pixels[0]) / self.figure.get_dpi(),
float(pixels[1]) / self.figure.get_dpi())
def draw(self):
pass # abstract, to be overridden by child classes
def __call__(self, shape, seed=None):
if seed is not None:
self.rng.seed(seed)
else:
self.rng.seed(int(time.time() * 100) % (2**32 - 1))
target_width, target_height = shape
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.gca()
ax.axis('off')
def central_crop(image, new_width, new_height):
image = image.copy()
width, height = image.size
left = (width - new_width) / 2
top = (height - new_height) / 2
right = (width + new_width) / 2
bottom = (height + new_height) / 2
image = image.crop((left, top, right, bottom))
return image
if self.rng.choice([True, False],
p=[self.fat_stroke_prob, 1 - self.fat_stroke_prob]):
stroke_index = self.rng.randint(0, len(self.strokes))
stroke_width = self.fat_stroke_width
stroke = self.strokes[
stroke_index][:int(len(self.strokes[stroke_index]) * 1)]
ax.plot(*stroke, color='black', lw=stroke_width)
else:
n_strokes = int(self.rng.normal(5, 1))
for _ in range(n_strokes):
stroke_index = self.rng.randint(0, len(self.strokes))
stroke_width = self.rng.randint(self.min_stroke_width,
self.max_stroke_width)
stroke = self.strokes[
stroke_index][:int(len(self.strokes[stroke_index]) * 1)]
ax.plot(*stroke, color='black', lw=stroke_width)
canvas.draw() # draw the canvas, cache the renderer
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.frombuffer(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width),
3)
image = Image.fromarray(image)
image = image.resize(
(int(1.25 * target_width), int(1.25 * target_height)))
image = central_crop(image, target_width, target_height)
image = image.convert('1')
return np.array(image).astype('float32')
def render(self, mode='human'):
"""
use PCA to plot users, items and actions.
:param mode:
:return:
"""
if mode == 'rgb_array':
users_vec = np.array(
[u.embedding for uid, u in self.users.items()])
items_vec = np.array(
[i.embedding for iid, i in self.items.items()])
# build dimensionality reduction if dims > 2
if items_vec.shape[1] > 2:
if not hasattr(self, 'pca'):
self.pca = PCA(n_components=2)
self.pca.fit(items_vec)
items = self.pca.transform(items_vec)
users = self.pca.transform(users_vec)
else:
items, users = items_vec, users_vec
fig = Figure(figsize=(5, 5))
canvas = FigureCanvas(fig)
ax = fig.gca()
ax.scatter(items[:, 0], items[:, 1], c='green', label='items')
ax.scatter(users[:, 0], users[:, 1], c='red', label='users')
# active user
x, y = users[self.active_user]
ax.scatter(x, y, marker='*', c='black', s=20, label='active user')
# active user recommendation history
# actions = self.last_actions[self.active_user]
# rewards = self.last_rewards[self.active_user]
# TODO: if item set will change will have problems
# if self.action_is_items:
# lines = [ [(x, y), a ] for a in actions]
# else:
# lines = [ [(x, y), (self.items[a][0], self.items[a][1])] for a in actions]
#
# c = [ 'yellow' if r else 'black' for r in rewards]
# lc = mc.LineCollection(lines, colors=c, linewidths=2)
# ax.add_collection(lc)
ax.legend()
ax.axis('off')
canvas.draw() # draw the canvas, cache the renderer
width, height = [
int(x) for x in fig.get_size_inches() * fig.get_dpi()
]
image = np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(height, width, 3)
return image
else:
pass
def __init__(self, figure: Figure, title: str, app: toga.App):
"""Initialize window."""
self.figure = figure
super().__init__(
title=title, size=(1, 1.35) * (figure.get_size_inches() * figure.get_dpi())
)
chart = Chart()
save_button = toga.Button(label="Save", on_press=self.save_figure)
save_box = toga.Box(children=[save_button])
chart_box = toga.Box(
children=[chart],
style=Pack(height=(figure.get_size_inches() * figure.get_dpi())[1]),
)
main_box = toga.Box(
children=[chart_box, save_box], style=Pack(direction=COLUMN)
)
self.content = main_box
chart.draw(figure)
self.app = app
def create_bounding_box(image_path,
image_size,
model,
*,
dpi=120,
topk=4,
grid_num=5):
model.eval()
image = Image.open(image_path)
im_h, im_w = image.size
# unsqueeze for make batch_size = 1
input = totensor(image.resize([image_size, image_size])).unsqueeze(0)
if cuda:
input = input.cuda()
output_loc, output_cnf, output_cls = model(Variable(input))
if cuda:
output_loc = output_loc.cpu()
output_cnf = output_cnf.cpu()
output_cls = output_cls.cpu()
# squeeze because batch is 1
output_cls.data.squeeze_(0), output_loc.data.squeeze_(0)
output_cnf = output_cnf.data[0, 0, :, :]
# get high confidence grids
grids = topk_2d(output_cnf, topk)
grid_size = image_size // grid_num
# load image for matplotlib
image = mpimg.imread(image_path)
fig = Figure(figsize=(im_h / dpi, im_w / dpi), dpi=dpi)
canvas = FigureCanvas(fig)
ax = fig.gca()
ax.imshow(image)
for grid_x, grid_y in grids:
x_0, x_1, y_0, y_1 = get_bbox_points(output_loc.data, grid_x, grid_y,
grid_size, im_w, im_h, image_size)
ax.plot([y_0, y_0, y_1, y_1, y_0], [x_0, x_1, x_1, x_0, x_0])
ax.text(y_0,
x_0,
f"{id_class[find_cls(output_cls[:, grid_x, grid_y])]}",
bbox={'alpha': 0.5})
ax.axis('off')
canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.fromstring(canvas.tostring_rgb(),
dtype='uint8').reshape(int(height), int(width), 3)
# numpy array -> PIL data -> tensor
tensor = totensor(Image.fromarray(image))
# image is numpy array and tensor is tensor
return image, tensor
def get_star_metrics(epoch, X, Y, emulated):
my_dpi = 72.0
fig = Figure(figsize=(720 / my_dpi, 360 / my_dpi),
dpi=my_dpi,
tight_layout=True)
canvas = plotting.plot_confusion_matrix(fig, X, Y, emulated)
width, height = fig.get_size_inches() * fig.get_dpi()
conf_mat = np.frombuffer(canvas.tostring_rgb(),
dtype='uint8').reshape(1, int(height), int(width),
3)
return conf_mat
class IdentifyMatplotlibPanel(wx.Panel):
def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)):
#(0) Initialize panel:
wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label)
self.SetMinSize(size)
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8,)*3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
def _create_axes(self):
self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3)
# self.plot(None)
# self.ax.plot( np.random.randn(10) )
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple( self.GetClientSize() )
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi()
self.figure.set_size_inches( szInches[0] , szInches[1] )
def cla(self):
self.ax.cla()
self.ax.set_position([0,0,1,1])
self.ax.set_axis_bgcolor([0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I, cmax=None):
if I!=None:
if cmax==None:
cmax = I.max()
I[I==0] = np.nan
self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax)
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05]*3)
self.ax.axis('image')
self.canvas.draw()
def points_to_pixels(length_points: float, fig: Figure) -> float:
"""
Convert a length in points to a length in display coordinates.
:param length_points: An absolute size, in points (1/72-th of an inch).
:param fig: Provides the DPI (pixels-per-inch) setting for conversion.
:return: A length in display coordinates (i.e. pixels).
"""
pixels_per_inch = fig.get_dpi()
length_inches = length_points * INCHES_PER_POINT
length_pixels = length_inches * pixels_per_inch
return length_pixels
def get_sample_cornerplot(Y_nat, sampled_result):
n_obj, n_sample, reg_dim = sampled_result.shape
my_dpi = 72.0
fig = Figure(figsize=(720 / my_dpi, 360 / my_dpi),
dpi=my_dpi,
tight_layout=True)
canvas = plotting.plot_sample_corner(fig, X, Y, emulated, flux_formatting,
bp)
width, height = fig.get_size_inches() * fig.get_dpi()
img = np.frombuffer(canvas.tostring_rgb(),
dtype='uint8').reshape(1, int(height), int(width), 3)
return img
class myWxPlot(wx.Panel):
def __init__(self, parent):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
self.parent = parent
wx.Panel.__init__(self, parent)
#matplotlib figure
self.figure = Figure(None)
self.figure.set_facecolor((0.7, 0.7, 1.))
self.subplot = self.figure.add_subplot(111)
#canvas
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.canvas.SetBackgroundColour(wx.Colour(100, 255, 255))
self._SetSize()
self.draw2()
def _SetSize(self):
size = tuple(self.parent.GetClientSize())
self.SetSize(size)
self.canvas.SetSize(size)
self.figure.set_size_inches(
float(size[0]) / self.figure.get_dpi(),
float(size[1]) / self.figure.get_dpi())
def draw(self):
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
x = np.arange(-3, 3, 0.25)
y = np.arange(-3, 3, 0.25)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) + np.cos(Y)
ax = Axes3D(self.figure)
ax.plot_wireframe(X, Y, Z)
def draw2(self):
import numpy as np
theta = np.arange(0, 200, 0.1)
x = 2 * np.cos(theta / 7)
y = 3 * np.sin(theta / 3)
self.subplot.plot(x, y, '-r')
self.subplot.set_title("Sample", fontsize=12)
self.subplot.set_xlabel("x")
self.subplot.set_ylabel("y")
self.subplot.set_xlim([-4, 4])
self.subplot.set_ylim([-4, 4])
class WXMatPlotLibPanel( wx.Panel ):
def __init__( self, parent, color=None, dpi=None, **kwargs ):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
# initialize Panel
if 'id' not in kwargs.keys():
kwargs['id'] = wx.ID_ANY
if 'style' not in kwargs.keys():
kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE
wx.Panel.__init__( self, parent, **kwargs )
# initialize matplotlib stuff
self.figure = Figure( None, dpi )
self.canvas = FigureCanvasWxAgg( self, -1, self.figure )
#self.SetColor( color )
self._SetSize()
self.draw()
self._resizeflag = False
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def SetColor( self, rgbtuple=None ):
"""Set figure and canvas colours to be the same."""
if rgbtuple is None:
rgbtuple = wx.SystemSettings.GetColour( wx.SYS_COLOUR_BTNFACE ).Get()
clr = [c/255. for c in rgbtuple]
self.figure.set_facecolor( clr )
self.figure.set_edgecolor( clr )
self.canvas.SetBackgroundColour( wx.Colour( *rgbtuple ) )
def _onSize( self, event ):
self._resizeflag = True
def _onIdle( self, evt ):
if self._resizeflag:
self._resizeflag = False
self._SetSize()
def _SetSize( self ):
pixels = tuple( self.parent.GetClientSize() )
self.SetSize( pixels )
self.canvas.SetSize( pixels )
self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(),
float( pixels[1] )/self.figure.get_dpi() )
def draw(self): pass # abstract, to be overridden by child classes
class MyPlotNoBlit(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self,parent, -1)
self.fig=Figure()
self.canvas=FigureCanvas(self,-1,self.fig)
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
self._resizeFlag = True
sizer=wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas,1,wx.GROW)
self.SetSizer(sizer)
def _onSize(self, evt):
self._resizeFlag = True
def _onIdle(self, evt):
if self._resizeFlag:
self._resizeFlag = False
self._SetSize()
self.draw()
def _SetSize(self, pixels=None):
if not pixels:
pixels = self.GetClientSize()
self.canvas.SetSize(pixels)
self.fig.set_size_inches(pixels[0]/self.fig.get_dpi(),
pixels[1]/self.fig.get_dpi())
def Plot(self, y):
a = self.fig.add_subplot(111)
a.plot(y)
def draw(self):
print 'draw!'
class PlotPlotPanel(wx.Panel):
def __init__(self, parent, dpi=None, **kwargs):
wx.Panel.__init__(self, parent, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, **kwargs)
self.ztv_frame = self.GetTopLevelParent()
self.figure = Figure(dpi=None, figsize=(1.,1.))
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.Bind(wx.EVT_SIZE, self._onSize)
def _onSize(self, event):
self._SetSize()
def _SetSize(self):
pixels = tuple(self.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi())
def render_to_response(self, context):
"""Create a png image and write the control chart image to it"""
fig = Figure(dpi=72, facecolor="white")
dpi = fig.get_dpi()
fig.set_size_inches(
self.get_number_from_request("width", 700) / dpi,
self.get_number_from_request("height", 480) / dpi,
)
canvas = FigureCanvas(fig)
dates, data = [], []
if context["data"] and context["data"].values():
name, points = context["data"].items()[0]
dates, data = zip(*[(ti["date"], ti["value"]) for ti in points])
n_baseline_subgroups = self.get_number_from_request("n_baseline_subgroups", 2, dtype=int)
n_baseline_subgroups = max(2, n_baseline_subgroups)
subgroup_size = self.get_number_from_request("subgroup_size", 2, dtype=int)
if not (1 < subgroup_size < 100):
subgroup_size = 1
include_fit = self.request.GET.get("fit_data", "") == "true"
response = HttpResponse(mimetype="image/png")
if n_baseline_subgroups < 1 or n_baseline_subgroups > len(data) / subgroup_size:
fig.text(0.1, 0.9, "Not enough data for control chart", fontsize=20)
canvas.print_png(response)
else:
try:
control_chart.display(fig, numpy.array(data), subgroup_size, n_baseline_subgroups, fit=include_fit, dates=dates)
fig.autofmt_xdate()
canvas.print_png(response)
except (RuntimeError, OverflowError) as e: # pragma: nocover
fig.clf()
msg = "There was a problem generating your control chart:\n%s" % str(e)
fig.text(0.1, 0.9, "\n".join(textwrap.wrap(msg, 40)), fontsize=12)
canvas.print_png(response)
return response
from matplotlib.figure import Figure
panel = wx.Panel(frame)
#matplotlib figure
figure = Figure( None )
figure.set_facecolor( (0.7,0.7,1.) )
subplot = figure.add_subplot( 111 )
#canvas
canvas = FigureCanvasWxAgg( panel, -1, figure )
canvas.SetBackgroundColour( wx.Color( 100,255,255 ) )
size = tuple( frame.GetClientSize() )
panel.SetSize( size )
canvas.SetSize( size )
figure.set_size_inches( float( size[0] )/figure.get_dpi(),float( size[1] )/figure.get_dpi() )
import numpy as np
theta = np.arange(0,200, 0.1)
x = 2*np.cos(theta/7)
y = 3*np.sin(theta/3)
subplot.plot(x,y, '-r')
subplot.set_title("Sample", fontsize = 12)
subplot.set_xlabel("x")
subplot.set_ylabel("y")
subplot.set_xlim([-4, 4])
subplot.set_ylim([-4, 4])
frame.Show()
app.MainLoop()
class PlotController(DialogMixin):
"""
A base class for matplotlib-canvas controllers that, sets up the
widgets and has image exporting functionality.
"""
file_filters = ("Portable Network Graphics (PNG)", "*.png"), \
("Scalable Vector Graphics (SVG)", "*.svg"), \
("Portable Document Format (PDF)", "*.pdf")
_canvas = None
@property
def canvas(self):
if not self._canvas:
self.setup_figure()
self.setup_canvas()
self.setup_content()
return self._canvas
# ------------------------------------------------------------
# Initialisation and other internals
# ------------------------------------------------------------
def __init__(self):
self._proxies = dict()
self.setup_figure()
self.setup_canvas()
self.setup_content()
def setup_figure(self):
style = gtk.Style()
self.figure = Figure(dpi=72, edgecolor=str(style.bg[2]), facecolor=str(style.bg[0]))
self.figure.subplots_adjust(hspace=0.0, wspace=0.0)
def setup_canvas(self):
self._canvas = FigureCanvasGTK(self.figure)
def setup_content(self):
raise NotImplementedError
# ------------------------------------------------------------
# Update subroutines
# ------------------------------------------------------------
def draw(self):
try:
self.figure.canvas.draw()
self.fix_after_drawing()
except ParseFatalException:
logger.exception("Caught unhandled exception when drawing")
def fix_after_drawing(self):
pass # nothing to fix
# ------------------------------------------------------------
# Graph exporting
# ------------------------------------------------------------
def save(self, parent=None, suggest_name="graph", size="auto", num_specimens=1, offset=0.75):
"""
Displays a save dialog to export an image from the current plot.
"""
# Parse arguments:
width, height = 0, 0
if size == "auto":
descr, width, height, dpi = settings.OUTPUT_PRESETS[0]
else:
width, height, dpi = map(float, size.replace("@", "x").split("x"))
# Load gui:
builder = gtk.Builder()
builder.add_from_file(resource_filename("pyxrd.specimen", "glade/save_graph_size.glade")) # FIXME move this to this namespace!!
size_expander = builder.get_object("size_expander")
cmb_presets = builder.get_object("cmb_presets")
# Setup combo with presets:
cmb_store = gtk.ListStore(str, int, int, float)
for row in settings.OUTPUT_PRESETS:
cmb_store.append(row)
cmb_presets.clear()
cmb_presets.set_model(cmb_store)
cell = gtk.CellRendererText()
cmb_presets.pack_start(cell, True)
cmb_presets.add_attribute(cell, 'text', 0)
def on_cmb_changed(cmb, *args):
itr = cmb_presets.get_active_iter()
w, h, d = cmb_store.get(itr, 1, 2, 3)
entry_w.set_text(str(w))
entry_h.set_text(str(h))
entry_dpi.set_text(str(d))
cmb_presets.connect('changed', on_cmb_changed)
# Setup input boxes:
entry_w = builder.get_object("entry_width")
entry_h = builder.get_object("entry_height")
entry_dpi = builder.get_object("entry_dpi")
entry_w.set_text(str(width))
entry_h.set_text(str(height))
entry_dpi.set_text(str(dpi))
# What to do when the user wants to save this:
def on_accept(dialog):
# Get the selected file type and name:
cur_fltr = dialog.get_filter()
filename = dialog.get_filename()
# Add the correct extension if not present yet:
for fltr in self.file_filters:
if cur_fltr.get_name() == fltr[0]:
if filename[len(filename) - 4:] != fltr[1][1:]:
filename = "%s%s" % (filename, fltr[1][1:])
break
# Get the width, height & dpi
width = float(entry_w.get_text())
height = float(entry_h.get_text())
dpi = float(entry_dpi.get_text())
i_width, i_height = width / dpi, height / dpi
# Save it all right!
self.save_figure(filename, dpi, i_width, i_height)
# Ask the user where, how and if he wants to save:
self.run_save_dialog("Save Graph", on_accept, None, parent=parent, suggest_name=suggest_name, extra_widget=size_expander)
def save_figure(self, filename, dpi, i_width, i_height):
"""
Save the current plot
Arguments:
filename: the filename to save to (either .png, .pdf or .svg)
dpi: Dots-Per-Inch resolution
i_width: the width in inch
i_height: the height in inch
"""
# Get original settings:
original_dpi = self.figure.get_dpi()
original_width, original_height = self.figure.get_size_inches()
# Set everything according to the user selection:
self.figure.set_dpi(dpi)
self.figure.set_size_inches((i_width, i_height))
self.figure.canvas.draw() # replot
bbox_inches = matplotlib.transforms.Bbox.from_bounds(0, 0, i_width, i_height)
# Save the figure:
self.figure.savefig(filename, dpi=dpi, bbox_inches=bbox_inches)
# Put everything back the way it was:
self.figure.set_dpi(original_dpi)
self.figure.set_size_inches((original_width, original_height))
self.figure.canvas.draw() # replot
class PhotPlotPanel(wx.Panel):
def __init__(self, parent, dpi=None, **kwargs):
wx.Panel.__init__(self, parent, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, **kwargs)
self.ztv_frame = self.GetTopLevelParent()
self.figure = Figure(dpi=None, figsize=(1.,1.))
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.Bind(wx.EVT_SIZE, self._onSize)
self.axes_widget = AxesWidget(self.figure.gca())
self.axes_widget.connect_event('motion_notify_event', self.on_motion)
self.axes_widget.connect_event('button_press_event', self.on_button_press)
self.axes_widget.connect_event('button_release_event', self.on_button_release)
self.axes_widget.connect_event('figure_leave_event', self.on_cursor_leave)
self.button_down = False
def on_button_press(self, event):
self.aper_names = ['aprad', 'skyradin', 'skyradout']
self.aper_last_radii = np.array([self.ztv_frame.phot_panel.aprad,
self.ztv_frame.phot_panel.skyradin,
self.ztv_frame.phot_panel.skyradout])
self.button_press_xdata = event.xdata
self.cur_aper_index = np.abs(self.aper_last_radii - event.xdata).argmin()
self.cur_aper_name = self.aper_names[self.cur_aper_index]
# but, click must be within +-N pix to be valid
if np.abs(event.xdata - self.aper_last_radii[self.cur_aper_index]) <= 20:
self.button_down = True
def on_motion(self, event):
if self.button_down:
if event.xdata is not None:
if self.cur_aper_name == 'aprad':
self.ztv_frame.phot_panel.aprad = (self.aper_last_radii[self.cur_aper_index] +
(event.xdata - self.button_press_xdata))
self.ztv_frame.phot_panel.aprad_textctrl.SetValue('{0:.2f}'.format(self.ztv_frame.phot_panel.aprad))
set_textctrl_background_color(self.ztv_frame.phot_panel.aprad_textctrl, 'ok')
elif self.cur_aper_name == 'skyradin':
self.ztv_frame.phot_panel.skyradin = (self.aper_last_radii[self.cur_aper_index] +
(event.xdata - self.button_press_xdata))
self.ztv_frame.phot_panel.skyradin_textctrl.SetValue('{0:.2f}'.format(
self.ztv_frame.phot_panel.skyradin))
set_textctrl_background_color(self.ztv_frame.phot_panel.skyradin_textctrl, 'ok')
elif self.cur_aper_name == 'skyradout':
self.ztv_frame.phot_panel.skyradout = (self.aper_last_radii[self.cur_aper_index] +
(event.xdata - self.button_press_xdata))
self.ztv_frame.phot_panel.skyradout_textctrl.SetValue('{0:.2f}'.format(
self.ztv_frame.phot_panel.skyradout))
set_textctrl_background_color(self.ztv_frame.phot_panel.skyradout_textctrl, 'ok')
self.ztv_frame.phot_panel.recalc_phot()
def on_button_release(self, event):
if self.button_down:
if event.xdata is not None:
if self.cur_aper_name == 'aprad':
self.ztv_frame.phot_panel.aprad = (self.aper_last_radii[self.cur_aper_index] +
(event.xdata - self.button_press_xdata))
self.ztv_frame.phot_panel.aprad_textctrl.SetValue('{0:.2f}'.format(self.ztv_frame.phot_panel.aprad))
set_textctrl_background_color(self.ztv_frame.phot_panel.aprad_textctrl, 'ok')
elif self.cur_aper_name == 'skyradin':
self.ztv_frame.phot_panel.skyradin = (self.aper_last_radii[self.cur_aper_index] +
(event.xdata - self.button_press_xdata))
self.ztv_frame.phot_panel.skyradin_textctrl.SetValue('{0:.2f}'.format(
self.ztv_frame.phot_panel.skyradin))
set_textctrl_background_color(self.ztv_frame.phot_panel.skyradin_textctrl, 'ok')
elif self.cur_aper_name == 'skyradout':
self.ztv_frame.phot_panel.skyradout = (self.aper_last_radii[self.cur_aper_index] +
(event.xdata - self.button_press_xdata))
self.ztv_frame.phot_panel.skyradout_textctrl.SetValue('{0:.2f}'.format(
self.ztv_frame.phot_panel.skyradout))
set_textctrl_background_color(self.ztv_frame.phot_panel.skyradout_textctrl, 'ok')
self.ztv_frame.phot_panel.recalc_phot()
self.button_down = False
def on_cursor_leave(self, event):
if self.button_down:
if self.cur_aper_name == 'aprad':
self.ztv_frame.phot_panel.aprad = self.aper_last_radii[self.cur_aper_index]
self.ztv_frame.phot_panel.aprad_textctrl.SetValue('{0:.2f}'.format(self.ztv_frame.phot_panel.aprad))
set_textctrl_background_color(self.ztv_frame.phot_panel.aprad_textctrl, 'ok')
elif self.cur_aper_name == 'skyradin':
self.ztv_frame.phot_panel.skyradin = self.aper_last_radii[self.cur_aper_index]
self.ztv_frame.phot_panel.skyradin_textctrl.SetValue('{0:.2f}'.format(
self.ztv_frame.phot_panel.skyradin))
set_textctrl_background_color(self.ztv_frame.phot_panel.skyradin_textctrl, 'ok')
elif self.cur_aper_name == 'skyradout':
self.ztv_frame.phot_panel.skyradout = self.aper_last_radii[self.cur_aper_index]
self.ztv_frame.phot_panel.skyradout_textctrl.SetValue('{0:.2f}'.format(
self.ztv_frame.phot_panel.skyradout))
set_textctrl_background_color(self.ztv_frame.phot_panel.skyradout_textctrl, 'ok')
self.ztv_frame.phot_panel.recalc_phot()
self.button_down=False
def _onSize(self, event):
self._SetSize()
def _SetSize(self):
pixels = tuple(self.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi())
def TRTimage( TRTcell_IDs, TRTcells, obj_area, minRank=8, alpha_max=1.0, plot_vel=True):
# define size of image
nx = obj_area.x_size
ny = obj_area.y_size
# create new figure
fig = Figure()
# canvas figure
canvas = FigureCanvas(fig)
# get dots per inch of the screen
DPI = fig.get_dpi()
# print "DPI", DPI
fig.set_size_inches(nx/float(DPI),ny/float(DPI))
# get axis object
ax = fig.add_subplot(111, aspect='equal')
## eliminates margins totally
fig.subplots_adjust(left=0.0,right=1.0,bottom=0.0,top=1.0, wspace=0, hspace=0)
#plt.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0, hspace=0) # does only work with x11 display
# set limits of the axis
ax.set_xlim(0, nx)
ax.set_ylim(0, ny)
# set transparent backgroud
fig.patch.set_alpha(0.0) # transparent outside of diagram
ax.set_axis_bgcolor([1,0,0,0]) # transparent color inside diagram
# define arrow properties
head_width = 0.006 * min(obj_area.x_size,obj_area.x_size)
head_length = 2 * head_width
pixel_size_x_km = 0.001 * obj_area.pixel_size_x
pixel_size_y_km = 0.001 * obj_area.pixel_size_y
for cell in TRTcell_IDs:
if TRTcells[cell].RANKr > minRank:
(x0,y0) = obj_area.get_xy_from_lonlat(TRTcells[cell].lon, TRTcells[cell].lat, outside_error=False, return_int=False)
y0 = (obj_area.y_size-1)-y0
# print (x0,y0)
vx = TRTcells[cell].vel_x
vy = TRTcells[cell].vel_y
# !!!scaling of width and height is not correct, that is on map projection, but not on the ground!!!
e = Ellipse( xy = (x0, y0), \
width = 2*TRTcells[cell].ell_S / pixel_size_x_km, \
height = 2*TRTcells[cell].ell_L / pixel_size_y_km, \
angle = -TRTcells[cell].angle )
ax.add_artist(e)
e.set_clip_box(ax.bbox)
if TRTcells[cell].RANKr <= 12:
cell_color="white"
alpha = (alpha_max-0.2) / 12. * TRTcells[cell].RANKr
elif TRTcells[cell].RANKr <= 15:
cell_color="white"
alpha = alpha_max
elif TRTcells[cell].RANKr <= 25:
cell_color="green"
alpha = alpha_max
elif TRTcells[cell].RANKr <= 35:
cell_color="yellow"
alpha = alpha_max
else:
cell_color="red"
alpha = alpha_max
# print "cell ID: %s, cell rank: %2d, cell_color:%7s, alpha = %4.1f" % (cell, TRTcells[cell].RANKr, cell_color, alpha)
e.set_alpha(alpha) # transparency: 0.0 transparent, 1 total visible
e.set_facecolor(cell_color) # "white" or [1,1,1]
if plot_vel:
ax.arrow(x0, y0, vx, vy, head_width = head_width, head_length = head_length, fc=cell_color, ec=cell_color)
if 1==1:
# print " !!! convert fig to image by function fig2img !!!"
### this would avoid saving into a file, but it fills the transparent areas with "white"
PIL_image = fig2img ( fig )
else:
tmp_file = '/tmp/TRT_'+str(uuid4())+'.png'
# print tmp_file
plt.savefig(tmp_file, dpi=DPI, transparent=True) #, bbox_inches='tight'
# subprocess.call("display "+tmp_file+" &", shell=True)
PIL_image = PIL_Image.open(tmp_file)
subprocess.call("rm "+tmp_file+" &", shell=True)
return PIL_image
class MatplotlibPanel(wx.Panel):
def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25), panelnum=0):
#(0) Initialize panel:
wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label)
self.SetMinSize(size)
self.parent = parent
self.panelnum = panelnum
#(1) Create Matplotlib figure:
self.figure = Figure(facecolor=(0.8,)*3)
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self._resize()
self._create_axes()
self.cidButtonDown = self.canvas.mpl_connect('button_press_event', self.callback_button_press)
def _create_axes(self):
self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[])
def _resize(self):
szPixels = tuple( self.GetClientSize() )
self.canvas.SetSize(szPixels)
szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi()
self.figure.set_size_inches( szInches[0] , szInches[1] )
def callback_button_press(self, event):
xy = event.xdata, event.ydata
shift = event.guiEvent.m_shiftDown
if xy != (None,None):
xy = map(int, np.round(xy))
if event.button==1:
if shift:
self.parent.parent.poi_select(xy, self.panelnum)
else: #add POI
self.parent.parent.poi_add(xy, self.panelnum)
else: #delete closest POI
self.parent.parent.poi_delete(xy, self.panelnum)
def cla(self):
self.ax.cla()
self.ax.set_position([0,0,1,1])
self.ax.set_axis_bgcolor([0.5]*3)
pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1))
self.ax.axis('tight')
self.canvas.draw()
def plot(self, I, cmax=None):
if I!=None:
if cmax==None:
cmax = I.max()
I[I==0] = np.nan
self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax)
pyplot.setp(self.ax, xticks=[], yticks=[])
self.ax.set_axis_bgcolor([0.05]*3)
self.ax.axis('image')
self.canvas.draw()
def highlight_poi(self, ind):
for i,line in enumerate(self.ax.lines):
if i==ind:
pyplot.setp(line, color='g', markersize=12)
else:
pyplot.setp(line, color='w', markersize=8)
self.canvas.draw()
def plot_poi(self, xy):
x,y = xy
i = len(self.ax.texts) + 1
self.ax.plot(x, y, 'wo', markersize=8)
self.ax.text(x+1, y+1, '%d'%i, bbox=dict(facecolor='w'))
def replot_pois(self, pois):
self.ax.lines = []
self.ax.texts = []
if pois:
[self.plot_poi(xy) for xy in pois]
self.canvas.draw()
class BarPanel (wx.Panel):
"""The BarPanel has a Figure and a Canvas. OnSize events simply set a flag,
and the actual resizing of the figure is triggered by an Idle event."""
def __init__( self, parent, color=None, dpi=None, **kwargs ):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
self.parent=parent
wx.Panel.__init__( self, parent, **kwargs )
# initialize matplotlib stuf
self.figure = Figure( None, dpi )
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self, -1, self.figure)
self.SetColor( color )
self._SetSize()
self.speedup1=[1.,1.,1.,1.,1.,1.,1.] #used for rolling average
self.speedup2=[1.,1.,1.,1.,1.,1.,1.]
self._resizeflag = False
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def SetColor( self, rgbtuple=None ):
"""Set figure and canvas colours to be the same."""
if rgbtuple is None:
rgbtuple = wx.SystemSettings.GetColour( wx.SYS_COLOUR_BTNFACE ).Get()
clr = [c/255. for c in rgbtuple]
self.figure.set_facecolor( clr )
self.figure.set_edgecolor( clr )
self.canvas.SetBackgroundColour( wx.Colour( *rgbtuple ) )
def _onSize( self, event ):
self._resizeflag = True
#print 'told to resize'
self._SetSize()
def _onIdle( self, evt ):
if self._resizeflag:
self._resizeflag = False
#print 'told to resize'
self._SetSize()
def _SetSize( self ):
pixels = self.GetClientSize() #tuple( self.parent.GetClientSize() )
self.SetSize( pixels )
self.canvas.SetSize( pixels )
self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(),
float( pixels[1] )/self.figure.get_dpi() )
def setData(self,inValList):
tempVals=inValList
#if tempVals[0]==0:
# tempVals[0]=1
tempVals[0]=0.00001
val1=tempVals[1]/float(tempVals[0])
if(val1<0.1):val1=0.1
val2=tempVals[2]/float(tempVals[0])
if(val2<0.1):val2=0.2
del self.speedup1[0]
self.speedup1.append(val1)
del self.speedup2[0]
self.speedup2.append(val2)
def draw(self):
self.axes.clear()
self.figure.subplots_adjust(top=0.83)
self.axes.bar([1,2,3],[0.01,mean(self.speedup1),mean(self.speedup2)],color=['r','b','g'])
self.axes.set_xticks([])
self.axes.set_yticks([])
self.axes.set_xticklabels([])
self.axes.set_yticklabels([])
self.axes.set_title('Speed Relative to GPU-ANN')
self.axes.text(0.001,0.5,r'$10^-5x$')
speedStr1 = '%4.3ex'%mean(self.speedup1)
speedStr2 = '%4.3ex'%mean(self.speedup2)
self.axes.text(2.05,mean(self.speedup1)*1.1,speedStr1)
self.axes.text(3.05,mean(self.speedup2)/2.0,speedStr2)
self.canvas.draw()
class PlotPanel (wx.Panel):
"""The PlotPanel has a Figure and a Canvas. OnSize events simply set a
flag, and the actual resizing of the figure is triggered by an Idle event."""
def __init__( self, parent, color=None, dpi=None, **kwargs ):
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
self.parent=parent
wx.Panel.__init__( self, parent, **kwargs )
# initialize matplotlib stuf
self.figure = Figure( None, dpi )
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self, -1, self.figure)
self.SetColor( color )
self._SetSize()
self.x=[]
self.y=[]
#self.draw()
self._resizeflag = False
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
def SetColor( self, rgbtuple=None ):
"""Set figure and canvas colours to be the same."""
if rgbtuple is None:
rgbtuple = wx.SystemSettings.GetColour( wx.SYS_COLOUR_BTNFACE ).Get()
clr = [c/255. for c in rgbtuple]
self.figure.set_facecolor( clr )
self.figure.set_edgecolor( clr )
self.canvas.SetBackgroundColour( wx.Colour( *rgbtuple ) )
def _onSize( self, event ):
self._resizeflag = True
#print 'told to resize'
self._SetSize()
def _onIdle( self, evt ):
if self._resizeflag:
self._resizeflag = False
#print 'told to resize'
self._SetSize()
def _SetSize( self ):
pixels = self.GetClientSize() #tuple( self.parent.GetClientSize() )
self.SetSize( pixels )
self.canvas.SetSize( pixels )
self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(),
float( pixels[1] )/self.figure.get_dpi() )
def draw(self):
if self.x != None and self.y !=None:
self.figure.subplots_adjust(left=0.145)
self.axes.plot(self.x[0][1:],self.y[0][1:], 'rv',linestyle='--',linewidth=4.0)
self.axes.plot(self.x[1][1:],self.y[1][1:], 'bo',linestyle=':',linewidth=2.0)
self.axes.plot(self.x[2][1:],self.y[2][1:], 'g.',linestyle='-',linewidth=1.0)
self.axes.legend(('PWScf','ANN','ANN-GPU'),loc='lower right',fancybox=True)
self.axes.set_ylim((0,-2.0))
self.axes.set_xlabel('Timestep')
self.axes.set_ylabel=('Mean Potential Energy')
#self.axes.set_xlim((0,3000))
#ticks=[0.98*self.y[2].max(),self.y[2].max(),1.02*self.y[2].max()]
#self.axes.set_ylim((ticks[0],ticks[2]))
#strLabels=['%.3f'%(0.98*ticks[0]),
# '%.3f'%ticks[1],
# '%.3f'%(1.02*ticks[2])]
#self.axes.set_yticklabels(strLabels)
#self.axes.set_yticks(ticks)
self.canvas.draw()
class MainPlotController(object):
"""
A controller for the main plot canvas.
Sets up the widgets and has image exporting functionality.
"""
file_filters = ("Portable Network Graphics (PNG)", "*.png"), \
("Scalable Vector Graphics (SVG)", "*.svg"), \
("Portable Document Format (PDF)", "*.pdf")
_canvas = None
@property
def canvas(self):
if not self._canvas:
self.setup_figure()
self.setup_canvas()
self.setup_content()
return self._canvas
# ------------------------------------------------------------
# View integration getters
# ------------------------------------------------------------
def get_toolbar_widget(self, window):
return NavigationToolbar(self.canvas, window)
def get_canvas_widget(self):
return self.canvas
# ------------------------------------------------------------
# Initialization and other internals
# ------------------------------------------------------------
def __init__(self, status_callback, marker_callback, *args, **kwargs):
self.setup_layout_cache()
self.setup_figure()
self.setup_canvas()
self.setup_content(status_callback, marker_callback)
def setup_layout_cache(self):
self.position_setup = PositionSetup()
self.labels = list()
self.marker_lbls = list()
self._proxies = dict()
self.scale = 1.0
self.stats = False
self._last_pos = None
def setup_figure(self):
self.figure = Figure(dpi=72, facecolor="#FFFFFF", linewidth=0)
self.figure.subplots_adjust(hspace=0.0, wspace=0.0)
def setup_canvas(self):
self._canvas = FigureCanvasGTK(self.figure)
def setup_content(self, status_callback, marker_callback):
# Create subplot and add it to the figure:
self.plot = Subplot(self.figure, 211, facecolor=(1.0, 1.0, 1.0, 0.0))
self.plot.set_autoscale_on(False)
self.figure.add_axes(self.plot)
# Connect events:
self.canvas.mpl_connect('draw_event', self.fix_after_drawing)
self.canvas.mpl_connect('resize_event', self.fix_after_drawing)
self.mtc = MotionTracker(self, status_callback)
self.cc = ClickCatcher(self, marker_callback)
#self.update()
# ------------------------------------------------------------
# Update methods
# ------------------------------------------------------------
def draw(self):
self._last_pos = self.fix_before_drawing()
self.figure.canvas.draw()
def fix_after_drawing(self, *args):
_new_pos = self.fix_before_drawing()
if _new_pos != self._last_pos:
self.figure.canvas.draw()
self._last_pos = _new_pos
return False
def fix_before_drawing(self, *args):
"""
Fixes alignment issues due to longer labels or smaller windows
Is executed after an initial draw event, since we can then retrieve
the actual label dimensions and shift/resize the plot accordingly.
"""
renderer = get_renderer(self.figure)
if not renderer or not self._canvas.get_realized():
return False
# Fix left side for wide specimen labels:
if len(self.labels) > 0:
bbox = self._get_joint_bbox(self.labels, renderer)
if bbox is not None:
self.position_setup.left = self.position_setup.default_left + bbox.width
# Fix top for high marker labels:
if len(self.marker_lbls) > 0:
bbox = self._get_joint_bbox([ label for label, flag, _ in self.marker_lbls if flag ], renderer)
if bbox is not None:
self.position_setup.top = self.position_setup.default_top - bbox.height
# Fix bottom for x-axis label:
bottom_label = self.plot.axis["bottom"].label
if bottom_label is not None:
bbox = self._get_joint_bbox([bottom_label], renderer)
if bbox is not None:
self.position_setup.bottom = self.position_setup.default_bottom + (bbox.ymax - bbox.ymin) * 2.0 # somehow we need this?
# Calculate new plot position & set it:
plot_pos = self.position_setup.position
self.plot.set_position(plot_pos)
# Adjust specimen label position
for label in self.labels:
label.set_x(plot_pos[0] - 0.025)
# Adjust marker label position
for label, flag, y_offset in self.marker_lbls:
if flag:
newy = plot_pos[1] + plot_pos[3] + y_offset - 0.025
label.set_y(newy)
_new_pos = self.position_setup.to_string()
return _new_pos
def update(self, clear=False, project=None, specimens=None):
"""
Updates the entire plot with the given information.
"""
if clear: self.plot.cla()
if project and specimens:
self.labels, self.marker_lbls = plot_specimens(
self.plot, self.position_setup, self.cc,
project, specimens
)
# get mixtures for the selected specimens:
plot_mixtures(self.plot, project, [ mixture for mixture in project.mixtures if any(specimen in mixture.specimens for specimen in specimens) ])
update_axes(
self.plot, self.position_setup,
project, specimens
)
self.draw()
# ------------------------------------------------------------
# Plot position and size calculations
# ------------------------------------------------------------
def _get_joint_bbox(self, container, renderer):
bboxes = []
try:
for text in container:
bbox = text.get_window_extent(renderer=renderer)
# the figure transform goes from relative coords->pixels and we
# want the inverse of that
bboxi = bbox.inverse_transformed(self.figure.transFigure)
bboxes.append(bboxi)
except (RuntimeError, ValueError):
logger.exception("Caught unhandled exception when joining boundig boxes")
return None # don't continue
# this is the bbox that bounds all the bboxes, again in relative
# figure coords
if len(bboxes) > 0:
bbox = transforms.Bbox.union(bboxes)
return bbox
else:
return None
# ------------------------------------------------------------
# Graph exporting
# ------------------------------------------------------------
def save(self, parent=None, current_name="graph", size="auto", num_specimens=1, offset=0.75):
"""
Displays a save dialog to export an image from the current plot.
"""
# Parse arguments:
width, height = 0, 0
if size == "auto":
descr, width, height, dpi = settings.OUTPUT_PRESETS[0]
else:
width, height, dpi = list(map(float, size.replace("@", "x").split("x")))
# Load gui:
builder = Gtk.Builder()
builder.add_from_file(resource_filename("pyxrd.specimen", "glade/save_graph_size.glade")) # FIXME move this to this namespace!!
size_expander = builder.get_object("size_expander")
cmb_presets = builder.get_object("cmb_presets")
# Setup combo with presets:
cmb_store = Gtk.ListStore(str, int, int, float)
for row in settings.OUTPUT_PRESETS:
cmb_store.append(row)
cmb_presets.clear()
cmb_presets.set_model(cmb_store)
cell = Gtk.CellRendererText()
cmb_presets.pack_start(cell, True)
cmb_presets.add_attribute(cell, 'text', 0)
def on_cmb_changed(cmb, *args):
itr = cmb.get_active_iter()
w, h, d = cmb_store.get(itr, 1, 2, 3)
entry_w.set_text(str(w))
entry_h.set_text(str(h))
entry_dpi.set_text(str(d))
cmb_presets.connect('changed', on_cmb_changed)
# Setup input boxes:
entry_w = builder.get_object("entry_width")
entry_h = builder.get_object("entry_height")
entry_dpi = builder.get_object("entry_dpi")
entry_w.set_text(str(width))
entry_h.set_text(str(height))
entry_dpi.set_text(str(dpi))
# What to do when the user wants to save this:
def on_accept(dialog):
# Get the width, height & dpi
width = float(entry_w.get_text())
height = float(entry_h.get_text())
dpi = float(entry_dpi.get_text())
i_width, i_height = width / dpi, height / dpi
# Save it all right!
self.save_figure(dialog.filename, dpi, i_width, i_height)
# Ask the user where, how and if he wants to save:
DialogFactory.get_save_dialog(
"Save Graph", parent=parent,
filters=self.file_filters, current_name=current_name,
extra_widget=size_expander
).run(on_accept)
def save_figure(self, filename, dpi, i_width, i_height):
"""
Save the current plot
Arguments:
filename: the filename to save to (either .png, .pdf or .svg)
dpi: Dots-Per-Inch resolution
i_width: the width in inch
i_height: the height in inch
"""
# Get original settings:
original_dpi = self.figure.get_dpi()
original_width, original_height = self.figure.get_size_inches()
# Set everything according to the user selection:
self.figure.set_dpi(dpi)
self.figure.set_size_inches((i_width, i_height))
self.figure.canvas.draw() # replot
bbox_inches = matplotlib.transforms.Bbox.from_bounds(0, 0, i_width, i_height)
# Save the figure:
self.figure.savefig(filename, dpi=dpi, bbox_inches=bbox_inches)
# Put everything back the way it was:
self.figure.set_dpi(original_dpi)
self.figure.set_size_inches((original_width, original_height))
self.figure.canvas.draw() # replot
pass # end of class
class MyFrame(wx.Frame):
def __init__(self, *args, **kwds):
# begin wxGlade: MyFrame.__init__
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
# Menu Bar
self.frame_1_menubar = wx.MenuBar()
wxglade_tmp_menu = wx.Menu()
wxglade_tmp_menu.Append(10, "load 4D file", "", wx.ITEM_NORMAL)
wxglade_tmp_menu.Append(11, "load python data", "", wx.ITEM_NORMAL)
self.frame_1_menubar.Append(wxglade_tmp_menu, "File")
wxglade_tmp_menu = wx.Menu()
wxglade_tmp_menu.Append(22, "Channel Properties", "", wx.ITEM_NORMAL)
self.frame_1_menubar.Append(wxglade_tmp_menu, "Edit")
wxglade_tmp_menu = wx.Menu()
wxglade_tmp_menu.Append(30, "tft", "", wx.ITEM_NORMAL)
self.frame_1_menubar.Append(wxglade_tmp_menu, "Execute")
self.SetMenuBar(self.frame_1_menubar)
# Menu Bar end
self.frame_1_statusbar = self.CreateStatusBar(1, 0)
# Tool Bar
self.frame_1_toolbar = wx.ToolBar(
self, -1, style=wx.TB_HORIZONTAL | wx.TB_DOCKABLE | wx.TB_TEXT | wx.TB_NOICONS
)
self.SetToolBar(self.frame_1_toolbar)
self.frame_1_toolbar.AddLabelTool(3, "PlotData", wx.NullBitmap, wx.NullBitmap, wx.ITEM_NORMAL, "", "")
self.frame_1_toolbar.AddLabelTool(1, "RePlot", wx.NullBitmap, wx.NullBitmap, wx.ITEM_NORMAL, "", "")
self.frame_1_toolbar.AddLabelTool(2, "ReDraw", wx.NullBitmap, wx.NullBitmap, wx.ITEM_NORMAL, "", "")
self.frame_1_toolbar.AddSeparator()
self.frame_1_toolbar.AddLabelTool(4, "TFT", wx.NullBitmap, wx.NullBitmap, wx.ITEM_CHECK, "", "")
# Tool Bar end
self.viewer = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
self.combo_box_1 = wx.ComboBox(
self,
-1,
choices=[".1sec", ".5sec", "1sec", "5sec", "10sec", "20sec", "30sec", "60sec"],
style=wx.CB_DROPDOWN | wx.CB_DROPDOWN | wx.CB_READONLY,
)
self.bitmap_button_2 = wx.BitmapButton(self, -1, wx.Bitmap("left.png", wx.BITMAP_TYPE_ANY))
self.bitmap_button_1 = wx.BitmapButton(self, -1, wx.Bitmap("right.png", wx.BITMAP_TYPE_ANY))
self.bitmap_button_3 = wx.BitmapButton(self, -1, wx.Bitmap("up.png", wx.BITMAP_TYPE_ANY))
self.bitmap_button_4 = wx.BitmapButton(self, -1, wx.Bitmap("down.png", wx.BITMAP_TYPE_ANY))
self.slider_3 = wx.Slider(
self, -1, 0, 0, 1, style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS | wx.SL_SELRANGE
)
self.slider_1 = wx.Slider(self, -1, 1, 0, 10, style=wx.SL_VERTICAL | wx.SL_AUTOTICKS | wx.SL_LABELS)
self.button_1 = wx.ToggleButton(self, -1, "AutoScale")
self.slider_2 = wx.Slider(self, -1, 1, 1, 100, style=wx.SL_VERTICAL | wx.SL_AUTOTICKS | wx.SL_LABELS)
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_MENU, self.loaddatagui, id=10)
self.Bind(wx.EVT_MENU, self.loadpythondata, id=11)
self.Bind(wx.EVT_MENU, self.chproperties, id=22)
self.Bind(wx.EVT_MENU, self.tftwindow, id=30)
self.Bind(wx.EVT_TOOL, self.plotloadeddata, id=3)
self.Bind(wx.EVT_TOOL, self.go, id=1)
self.Bind(wx.EVT_TOOL, self.redraw, id=2)
self.Bind(wx.EVT_TOOL, self.tftframe, id=4)
self.Bind(wx.EVT_COMBOBOX, self.settimewin, self.combo_box_1)
self.Bind(wx.EVT_BUTTON, self.panleft, self.bitmap_button_2)
self.Bind(wx.EVT_BUTTON, self.panright, self.bitmap_button_1)
self.Bind(wx.EVT_BUTTON, self.panup, self.bitmap_button_3)
self.Bind(wx.EVT_BUTTON, self.pandown, self.bitmap_button_4)
self.Bind(wx.EVT_COMMAND_SCROLL_THUMBTRACK, self.settimepnt, self.slider_3)
self.Bind(wx.EVT_COMMAND_SCROLL_PAGEDOWN, self.settimepnt, self.slider_3)
self.Bind(wx.EVT_COMMAND_SCROLL_PAGEUP, self.settimepnt, self.slider_3)
self.Bind(wx.EVT_COMMAND_SCROLL_LINEDOWN, self.settimepnt, self.slider_3)
self.Bind(wx.EVT_COMMAND_SCROLL_LINEUP, self.settimepnt, self.slider_3)
self.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.settimepnt, self.slider_3)
self.Bind(wx.EVT_COMMAND_SCROLL_PAGEDOWN, self.numchans, self.slider_1)
self.Bind(wx.EVT_COMMAND_SCROLL_ENDSCROLL, self.numchans, self.slider_1)
self.Bind(wx.EVT_COMMAND_SCROLL_PAGEUP, self.numchans, self.slider_1)
self.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.numchans, self.slider_1)
self.Bind(wx.EVT_TOGGLEBUTTON, self.autoscalehandler, self.button_1)
self.Bind(wx.EVT_COMMAND_SCROLL_THUMBTRACK, self.amplitudescale, self.slider_2)
self.Bind(wx.EVT_COMMAND_SCROLL_PAGEDOWN, self.amplitudescale, self.slider_2)
self.Bind(wx.EVT_COMMAND_SCROLL_PAGEUP, self.amplitudescale, self.slider_2)
self.Bind(wx.EVT_COMMAND_SCROLL_LINEDOWN, self.amplitudescale, self.slider_2)
self.Bind(wx.EVT_COMMAND_SCROLL_BOTTOM, self.amplitudescale, self.slider_2)
self.Bind(wx.EVT_COMMAND_SCROLL_LINEUP, self.amplitudescale, self.slider_2)
self.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.amplitudescale, self.slider_2)
# end wxGlade
event = 0
self.dpi = 50
left, width = 0.05, 0.8
rect1 = [left, 0.2, width, 0.79]
rect2 = [left, 0.1, width, 0.2]
self.fig = Figure(None, dpi=self.dpi)
# self.fig = Figure((8.0, 20.0), dpi=self.dpi)
self.canvas = FigCanvas(self.viewer, -1, self.fig)
self.redraw(event)
# ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab')
# ~ self.axes2 = self.fig.add_subplot(111,axisbg='#ababab', sharex=self.axes)
self.axes = self.fig.add_axes(rect1, axisbg="#ababab")
#####self.axes.yaxis.set_visible(False)
self.axes.set_frame_on(False)
self.axes2 = self.fig.add_axes(rect2, axisbg="#ababab") # , sharex=self.axes)
self.axes2.axis("on")
# ax2 = fig.add_axes(rect2, axisbg=axescolor, sharex=ax1)
# self.axes.axis('off')
event = 0
# self.loaddata(event)
# fn = '/home/danc/python/data/E0053/E0053_EEGSSPLR.pym'
# self.trials = 10
# #fn = '/home/danc/python/data/E0052/sim.pym'
# self.origdata, self.timeaxes, self.chlabels, self.srate = retrievepythondata(fn)
siz = self.GetSize()
self.canvas.SetClientSize((siz[0] - 1, siz[1] - 100))
self.zoomin(event)
self.pan(event)
# ~
# ~ from pylab import *
# ~ try:
# ~ import Image
# ~ except ImportError, exc:
# ~ raise SystemExit("PIL must be installed to run this example")
# ~
# lena = Image.open('AlbinoPython.jpg')
# ~ dpi = rcParams['figure.dpi']
# ~ figsize = lena.size[0]/dpi, lena.size[1]/dpi
# ~
# ~ figure(figsize=figsize)
# ~ ax = axes([0,0,1,1], frameon=False)
# ~ ax.set_axis_off()
# self.axes.imshow(lena, origin='lower')
# ~
# show()
def __set_properties(self):
# begin wxGlade: MyFrame.__set_properties
self.SetTitle("PyPlotter")
self.SetSize((600, 600))
self.frame_1_statusbar.SetStatusWidths([-1])
# statusbar fields
frame_1_statusbar_fields = ["PyPlotter"]
for i in range(len(frame_1_statusbar_fields)):
self.frame_1_statusbar.SetStatusText(frame_1_statusbar_fields[i], i)
self.frame_1_toolbar.SetToolPacking(5)
self.frame_1_toolbar.SetToolSeparation(5)
self.frame_1_toolbar.Realize()
self.viewer.SetBackgroundColour(wx.Colour(143, 143, 188))
self.viewer.SetScrollRate(10, 10)
self.combo_box_1.SetMinSize((87, 27))
self.combo_box_1.SetSelection(0)
self.bitmap_button_2.SetMinSize((55, 55))
self.bitmap_button_2.Enable(False)
self.bitmap_button_1.SetMinSize((55, 55))
self.bitmap_button_1.Enable(False)
self.bitmap_button_3.SetMinSize((55, 55))
self.bitmap_button_3.Enable(False)
self.bitmap_button_4.SetMinSize((55, 55))
self.bitmap_button_4.Enable(False)
self.slider_3.SetBackgroundColour(wx.Colour(216, 216, 191))
self.slider_3.SetToolTipString("Time Slider (sec)")
self.slider_3.SetFocus()
self.slider_1.SetToolTipString("Number of channels")
self.slider_1.Enable(False)
self.button_1.SetBackgroundColour(wx.Colour(143, 143, 188))
self.button_1.SetValue(1)
self.slider_2.SetToolTipString("Amplitude")
self.slider_2.Enable(False)
# end wxGlade
def __do_layout(self):
# begin wxGlade: MyFrame.__do_layout
sizer_1 = wx.BoxSizer(wx.VERTICAL)
sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
sizer_1.Add(self.viewer, 3, wx.ALL | wx.EXPAND | wx.ALIGN_BOTTOM, 0)
sizer_2.Add(self.combo_box_1, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL, 0)
sizer_2.Add(self.bitmap_button_2, 0, wx.ALIGN_CENTER_VERTICAL, 0)
sizer_2.Add(self.bitmap_button_1, 0, wx.ALIGN_CENTER_VERTICAL, 0)
sizer_2.Add(self.bitmap_button_3, 0, wx.ALIGN_CENTER_VERTICAL, 0)
sizer_2.Add(self.bitmap_button_4, 0, wx.ALIGN_CENTER_VERTICAL, 0)
sizer_2.Add(self.slider_3, 6, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL, 0)
sizer_2.Add(self.slider_1, 1, wx.ALL | wx.EXPAND, 0)
sizer_2.Add(self.button_1, 0, 0, 0)
sizer_2.Add(self.slider_2, 0, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL, 0)
sizer_1.Add(sizer_2, 0, wx.EXPAND | wx.ALIGN_BOTTOM, 0)
self.SetSizer(sizer_1)
self.Layout()
self.Centre()
# end wxGlade
# ~ self.dpi = 100
# ~ self.fig = Figure((8.0, 20.0), dpi=self.dpi)
# ~ self.canvas = FigCanvas(self.viewer, -1, self.fig)
# ~ sizer_1.Add(self.frame_1_toolbar, 5, wx.LEFT | wx.EXPAND)
# ~ self.redraw(event)
# ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab')
def passdata(data): # , samplerate, channellabels):
import sys
print sys.argv
import getopt
opts, extraparams = getopt.getopt(sys.argv[1:])
# ~ data = np.random.randn(10000,10)
# ~ self.origdata = data
# ~ self.sr = np.float32(100.0)
# ~ sp = 1/frame.sr
# ~ self.timeaxes = np.arange(0,sp*1000, sp)
# ~ self.chlabels = np.arange(0,244)
def go(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `go' "
self.draw_figure(event)
# self.redraw(event)
def clear(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `clear' not implemented"
print self.GetSize()
print self.fig.get_size_inches()
x = self.canvas.GetClientSize()
print x
# self.canvas.SetClientSize((x[0]/2,x[1]/2))
x = self.GetSize()
self.canvas.SetClientSize((x[0] / 0.8, x[1] / 0.9))
# self.canvas.Destroy()
# self.fig.clear()
def redraw(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `redraw' not implemented"
siz = self.GetSize()
self.canvas.SetClientSize((siz[0] - 1, siz[1] - 100))
self.canvas.Refresh(eraseBackground=True)
def amplitudescale(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `amwxplitudescale' not implemented"
print self.slider_2.GetValue()
dmin = self.origdata.min()
dmax = self.origdata.max()
print dmin, dmax
self.step = abs(dmin + dmax / 10) / self.slider_2.GetValue()
print "step2", self.step
# self.go(event)
# ~ self.numchans(event)
# return step/self.slider_2.GetValue()
# self.settimewin(event)
def numchans(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `numchans' not implemented"
self.slider_1.SetRange(0, np.size(self.origdata, 1))
self.data = self.origdata[:, 0 : self.slider_1.GetValue()]
self.label2plot = self.chlabels[0 : self.slider_1.GetValue()]
# self.settimewin(event)
try:
self.go(event)
except AttributeError:
print "error"
def settimewin(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `settimewin' not implemented"
# ~ self.startsec = self.slider_3.GetValue() * int(self.combo_box_1.GetValue().strip('sec'))
# ~ self.endsec = self.startsec + int(self.combo_box_1.GetValue().strip('sec'))
self.startsec = self.slider_3.GetValue()
self.endsec = self.startsec + np.float32(self.combo_box_1.GetValue().strip("sec"))
print "pp", self.startsec, self.endsec
self.indstart = np.argmin(abs(self.startsec - self.timeaxes))
self.indend = np.argmin(abs(self.endsec + -self.timeaxes))
print "ind", self.indstart, self.indend
self.canvas.Update()
self.go(event)
# self.go(event)
def settimepnt(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `settimepnt' not implemented"
self.settimewin(event)
# ~ self.timepnt = self.slider_3.GetValue()
# ~ self.indstart = argmin(abs(self.timepnt - self.timeaxes))
# ~ self.indend = argmin(abs(self.timepnt+ - self.timeaxes))
# ~
# ~ print self.indstart,
def setupwidgets(self):
self.slider_1.Enable(enable=True)
self.slider_2.Enable(enable=True)
self.bitmap_button_1.Enable(True)
self.bitmap_button_2.Enable(True)
self.bitmap_button_3.Enable(True)
self.bitmap_button_4.Enable(True)
self.combo_box_1.Enable(True)
x = []
for n in range(0, np.size(self.chlabels)):
x.append(str(n))
# self.combo_box_1.SetItems(unicode(self.chlabels.tolist()))
# self.combo_box_1.SetItems(x)
print self.timeaxes[0], self.timeaxes[-1]
self.slider_3.SetRange(self.timeaxes[0], self.timeaxes[-1])
def panleft(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `panleft' not implemented"
event.Skip()
def panright(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `panright' not implemented"
event.Skip()
def panup(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `panup' not implemented"
try:
self.e = self.s
self.s = self.e - self.slider_1.GetValue()
except AttributeError:
print "setting"
self.e = self.slider_1.GetValue()
self.s = self.e + self.e
if self.s < 0:
print "at start of channel set"
self.s = 0
self.e = self.s + self.slider_1.GetValue()
self.data = self.origdata[:, self.s : self.e]
print "du", self.s, self.e
self.label2plot = self.chlabels[self.s : self.e]
self.go(event)
def pandown(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `pandown' not implemented"
try:
self.s = self.e
self.e = self.s + self.slider_1.GetValue()
except AttributeError:
print "setting"
self.s = self.slider_1.GetValue()
self.e = self.s + self.s
if self.e > np.size(self.origdata, 1):
print "at end of channel set"
self.e = np.size(self.origdata, 1)
self.s = self.e - self.slider_1.GetValue()
self.data = self.origdata[:, self.s : self.e]
print "dd", self.s, self.e
self.label2plot = self.chlabels[self.s : self.e]
self.go(event)
def loaddatagui(self, event): # wxGlade: MyFrame.<event_handler>
self.datapath = "/home/danc/python/data/0611/0611piez/e,rfhp1.0Hz,COH"
import os
print "Event handler `loaddatagui' not implemented"
dlg = wx.FileDialog(self, "Select an Data file", os.getcwd(), "", "*", wx.OPEN)
if dlg.ShowModal() == wx.ID_OK:
self.datapath = dlg.GetPath()
dlg.Destroy()
# ~ dlg = wx.MessageDialog(self, 'First you need to load MRI data file', 'MRI file error', wx.OK|wx.ICON_INFORMATION)
# ~ dlg.ShowModal()
# ~ dlg.Destroy()
# from gui import pysel
# pysel.start()
# p#rint 'done', pysel.fnlist
self.origdata, self.timeaxes, self.chlabels, self.srate = retrievepdf(self.datapath) # self.datapath)
self.data = self.origdata
self.chproperties(event)
self.plotloadeddata(event)
# chpropertywin.loadchannels(event)
def plotloadeddata(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `plotdata' "
# print pysel.fnlist
# self.origdata, self.timeaxes, self.chlabels = getdata()
self.data = self.origdata
self.numchans(event)
self.amplitudescale(event)
self.settimewin(event)
# print 'labels', label2plot
self.setupwidgets()
self.go(event)
# self.numchans(event)
print "step", self.step
def loadpythondata(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `loadpythondata' not implemented"
import os
print "Event handler `loaddatagui' not implemented"
dlg = wx.FileDialog(
self,
"Select a python file(s)",
os.getcwd(),
"",
wildcard="Data File (*.pym)|*.pym|Dipole Report(*.drf)|*.drf",
)
if dlg.ShowModal() == wx.ID_OK:
self.datapath = dlg.GetPath()
dlg.Destroy()
self.origdata, self.timeaxes, self.chlabels = retrievepythondata(self.datapath) # self.datapath)
def autoscalehandler(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `autoscalehandler' not implemented"
if self.button_1.GetValue() == 0:
print "manual scaling"
scalewin.Show()
else:
print "auto scaling"
scalewin.Hide()
def tftinit(self, event): # wxGlade: MyFrame.<event_handler>
# if self.frame_1_toolbar.GetToolState(4) == True: #depressed
from meg import timef
t = timef.initialize()
self.redraw(event)
print self.tftch, self.trials, self.srate
# print 's', np.shape(self.origdata[self.indstart:self.indend,19]),np.shape(self.data[self.indstart:self.indend,19])
print "inds", self.indstart, "inde", self.indend
# dif = np.size(self.data[self.indstart:self.indend:19],0); print 'dif', dif, self.indend, self.indstart
dif = self.indend - self.indstart
print "dif", dif, self.indend, self.indstart
print "shape of data", np.shape(self.origdata[self.indstart : self.indend, self.tftch])
t.calc(
data=self.origdata[self.indstart : self.indend, self.tftch],
trials=self.trials,
srate=self.srate,
frames=dif / self.trials,
freqrange=[3.0, 100],
cycles=[2, 0.5],
)
# self.axes.plot(self.data[self.indstart:self.indend:,i]+inc, color=[0,0,0])
# self.axes2.imshow(abs(t.tmpallallepochs))#, aspect=6,extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0])));colorbar();show()
# self.axes2.imshow(abs(t.tmpallallepochs))#,aspect = 1, extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0])))
self.axes2.imshow(
abs(t.tmpallallepochs),
extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0])),
)
print "tftshape", np.shape(t.tmpallallepochs)
# self.redraw(event)
# self.axes2.update()
self.canvas.draw()
print "Event handler `tftinit' not implemented"
event.Skip()
def tftframe(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `tftframe' not implemented"
tftframe.Show()
def tftwindow(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `tftwindow' not implemented"
tftframe.Show()
def chproperties(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `chproperties' not implemented"
chpropertywin.Show()
chpropertywin.list_box_channels.SetItems(frame.chlabels)
for i in frame.chlabels:
index = chpropertywin.list_ctrl_1.InsertStringItem(sys.maxint, str(i))
chpropertywin.list_ctrl_1.SetStringItem(index, 1, i)
# self.list_ctrl_1.SetItem(i)
# self.list_ctrl_1.SetItem(frame.chlabels)
chpropertywin.chcolorlist = np.tile((0, 0, 0), (len(frame.chlabels), 1)) # set all channels to black
# end of class MyFrame
# -----------------------------------------------------
def pan(self, event):
import time
def on_press(event):
self.clicktime = time.time()
# self.releasetime = False
self.holdcheck = "yes"
# on_move(event)
# try:
# if self.clicktime
def on_release(event):
self.releasetime = time.time()
self.holdcheck = "no"
print "you released", event.button, event.xdata, event.ydata
self.canvas.draw()
def on_move(event):
try:
if self.holdcheck == "yes":
print "your pointer is at", event.xdata, event.ydata
x1, x2 = self.axes.get_xlim()
y1, y2 = self.axes.get_ylim()
print x1, x2, y1, y2, "::::", x2 - x1, y2 - y1
self.axes.set_xlim(event.xdata + (x2 - x1) / 2, event.xdata - (x2 - x1) / 2)
self.axes.set_ylim(event.ydata + (y2 - y1) / 2, event.ydata - (y2 - y1) / 2)
except AttributeError:
pass
# print 'no click yet'
cid = self.fig.canvas.mpl_connect("button_press_event", on_press)
rid = self.fig.canvas.mpl_connect("button_release_event", on_release)
mousemove = self.fig.canvas.mpl_connect("motion_notify_event", on_move)
def zoomin(self, event):
import time
def on_press(event):
try:
self.lasttime = self.curtime
except AttributeError:
self.lasttime = 0
self.curtime = time.time()
if np.round(self.curtime, 2) != np.round(self.lasttime, 2):
tdiff = self.curtime - self.lasttime
print "time diff", tdiff
print "you pressed", event.button, event.xdata, event.ydata
if tdiff < 0.25:
tdiff = 0
x1, x2 = self.axes.get_xlim()
y1, y2 = self.axes.get_ylim()
print x1, x2, y1, y2
# ~ self.axes.set_xlim(x1/2,x2/2)
# ~ self.axes.set_ylim(y1/2,y2/2)
# self.axes.set_xlim(event.xdata-(x2-x1)/2, event.xdata+(x2-x1)/2)
if event.button == 1: # zoom in
self.axes.set_xlim(event.xdata - (x2 - x1) / 4, event.xdata + (x2 - x1) / 4)
self.axes.set_ylim(event.ydata - (y2 - y1) / 4, event.ydata + (y2 - y1) / 4)
if event.button == 3: # zoom out
self.axes.set_xlim(event.xdata - (x2 - x1) * 1, event.xdata + (x2 - x1) * 1)
self.axes.set_ylim(event.ydata - (y2 - y1) * 1, event.ydata + (y2 - y1) * 1)
# self.axes.set_xlim(np.mean(event.xdata,x1), np.mean(event.xdata,x2))
# self.axes.set_ylim(np.mean(event.ydata,y1), np.mean(event.ydata,y2))
self.canvas.draw()
cid = self.fig.canvas.mpl_connect("button_press_event", on_press)
def axeslabels(self, data): # , chlabels, timelabels):
chlabels = np.arange(np.size(data, 1))
timelabels = ["100", "200", "300"]
# ~ if np.size(chlabels) != np.size(data,1):
# ~ print np.size(chlabels), np.size(data,1)
# ~ print 'channel label length differs from data'
# ~ #return
return chlabels, timelabels
def draw_figure(self, event):
# ~ try:
# ~ count = count + 1
# ~ except UnboundLocalError:
# ~ count = 0
# ~ if not hasattr(self, 'subplot'):
# ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab')
# ~ self._resizeflag = False
# ~ #self.axes.bar(left=10,height=100,width=100,align='center',alpha=0.44,picker=5)
# ~ self.dpi = 50
# ~ self.fig = Figure( None, dpi=self.dpi )
# ~ self.canvas = FigCanvas(self.viewer, -1, self.fig)
self.redraw(event)
# ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab')
# self.canvas.Update()
# self.canvas.UpdateRegion()
# self.canvas.Refresh()
self.axes.clear()
# ~ self.canvas.Close()
# self.canvas.gui_repaint()
self.canvas.Show()
# ~ print 'count',count
# self.axes.axis('off')
self.axes.grid("on")
inc = 0
print "drawshapestate", np.shape(self.origdata), np.shape(self.data), np.shape(
self.timeaxes
), self.indstart, self.indend
for i in range(0, np.size(self.data, 1))[::-1]:
# self.axes.plot(self.origdata[self.indstart:self.indend:,i]+inc)
colur = chpropertywin.chcolorlist[i] / 256.0
# ~ if i < 2:
# ~ colur = (0,0,1)
# ~ else:
# ~ colur = (0,0,0)
self.axes.plot(self.data[self.indstart : self.indend :, i] + inc, color=colur)
if self.frame_1_toolbar.GetToolState(4) == True: # depressed
# print 's', np.shape(self.origdata[self.indstart:self.indend,19]),np.shape(self.data[self.indstart:self.indend,19])
# t.calc(data=self.origdata[self.indstart:self.indend,19], trials=10, srate=290.64,frames=dif/10, freqrange=[5.0,70], cycles=[2, .5])
pass
# self.tftinit(event)
# self.axes2.imshow(abs(t.tmpallallepochs),aspect = 7, extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0])))
# self.axes.plot(self.data[:,i]+inc)
self.axes.text(0, inc, self.label2plot[i], color=[1, 0, 0])
inc = self.step / 2 + inc
# self.axes.update()
# self.axes.set_xlim((self.indstart,self.indend))
# self.canvas.Update()
def _onIdle(self, evt):
if self._resizeflag:
self._resizeflag = False
self._SetSize()
print "idle"
def _onSize(self, event):
self._resizeflag = True
def _SetSize(self):
pixels = tuple(self.GetClientSize())
self.SetSize(pixels)
self.canvas.SetSize(pixels)
self.fig.set_size_inches(float(pixels[0]) / self.fig.get_dpi(), float(pixels[1]) / self.fig.get_dpi())
class Chart(FigureCanvas):
"""Klasa (widget Qt) odpowiedzialna za rysowanie wykresu. Zgodnie z tym, co zasugerował
Paweł, na jednym wykresie wyświetlam jeden wskaźnik i jeden oscylator, a jak ktoś
będzie chciał więcej, to kliknie sobie jakiś guzik, który mu pootwiera kilka wykresów
w nowym oknie."""
#margines (pionowy i poziomy oraz maksymalna wysokość/szerokość wykresu)
margin, maxSize = 0.1, 0.8
#wysokość wolumenu i wykresu oscylatora
volHeight, oscHeight = 0.1, 0.15
def __init__(self, parent, finObj=None, width=8, height=6, dpi=100):
"""Konstruktor. Tworzy domyślny wykres (liniowy z wolumenem, bez wskaźników)
dla podanych danych. Domyślny rozmiar to 800x600 pixli"""
self.mainPlot=None
self.volumeBars=None
self.oscPlot=None
self.additionalLines = [] #lista linii narysowanych na wykresie (przez usera, albo przez wykrycie trendu)
self.rectangles = [] #lista prostokątów (do zaznaczania świec)
self.mainType = None #typ głównego wykresu
self.oscType = None #typ oscylatora (RSI, momentum, ...)
self.mainIndicator = None #typ wskaźnika rysowany dodatkowo na głównym wykresie (średnia krocząca, ...)
self.x0, self.y0 = None,None #współrzędne początku linii
self.drawingMode = False #zakładam, że możliwość rysowania będzie można włączyć/wyłączyć
self.scaleType = 'linear' #rodzaj skali na osi y ('linear' lub 'log')
self.grid = True #czy rysujemy grida
self.setData(finObj)
self.mainType='line'
self.fig = Figure(figsize=(width, height), dpi=dpi)
FigureCanvas.__init__(self, self.fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
self.addMainPlot()
self.addVolumeBars()
self.mpl_connect('button_press_event', self.onClick)
def setData(self, finObj, start=None, end=None, step='daily'):
"""Ustawiamy model danych, który ma reprezentować wykres. Następnie
konieczne jest jego ponowne odrysowanie"""
if(finObj==None):
return;
self.data=ChartData(finObj, start, end, step)
if(self.mainPlot!=None):
self.updatePlot()
def getData(self):
return self.data
def setGrid(self, grid):
"""Włącza (True) lub wyłącza (False) rysowanie grida"""
self.grid=grid
self.updateMainPlot()
def setMainType(self, type):
"""Ustawiamy typ głównego wykresu ('point','line','candlestick','none')"""
self.mainType=type
self.updateMainPlot()
def updatePlot(self):
"""Odświeża wszystkie wykresy"""
self.updateMainPlot()
self.updateVolumeBars()
self.updateOscPlot()
self.draw()
#self.drawGeometricFormation()
#self.drawRateLines()
#self.drawTrend()
#self.drawCandleFormations()
#self.drawGaps()
def addMainPlot(self):
"""Rysowanie głównego wykresu (tzn. kurs w czasie)"""
bounds=[self.margin, self.margin, self.maxSize, self.maxSize]
self.mainPlot=self.fig.add_axes(bounds)
self.updateMainPlot()
def updateMainPlot(self):
if(self.mainPlot==None or self.data==None or self.data.corrupted):
return
ax=self.mainPlot
ax.clear()
x=range(len(self.data.close))
if self.mainType=='line' :
ax.plot(x,self.data.close,'b-',label=self.data.name)
elif self.mainType=='point':
ax.plot(x,self.data.close,'b.',label=self.data.name)
elif self.mainType=='candlestick':
self.drawCandlePlot()
elif self.mainType=='bar':
self.drawBarPlot()
else:
return
if self.mainIndicator != None:
self.updateMainIndicator()
ax.set_xlim(x[0],x[-1])
ax.set_yscale(self.scaleType)
ax.set_ylim(0.995*min(self.data.low),1.005*max(self.data.high))
for line in self.additionalLines:
ax.add_line(line)
line.figure.draw_artist(line)
for rect in self.rectangles:
ax.add_patch(rect)
rect.figure.draw_artist(rect)
if(self.scaleType=='log'):
ax.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
ax.yaxis.set_minor_formatter(FormatStrFormatter('%.2f'))
for tick in ax.yaxis.get_major_ticks():
tick.label2On=True
if(self.grid):
tick.gridOn=True
for label in (ax.get_yticklabels() + ax.get_yminorticklabels()):
label.set_size(8)
#legenda
leg = ax.legend(loc='best', fancybox=True)
leg.get_frame().set_alpha(0.5)
self.formatDateAxis(self.mainPlot)
self.fixTimeLabels()
if(self.grid):
for tick in ax.xaxis.get_major_ticks():
# print tick.get_loc()
tick.gridOn=True
def addVolumeBars(self):
"""Dodaje do wykresu wyświetlanie wolumenu."""
#tworzymy nowy wykres tylko za pierwszym razem, potem tylko pokazujemy i odświeżamy
if(self.volumeBars==None):
volBounds=[self.margin, self.margin, self.maxSize, self.volHeight]
self.volumeBars=self.fig.add_axes(volBounds, sharex=self.mainPlot)
self.updateVolumeBars()
self.volumeBars.set_visible(True)
self.fixPositions()
self.fixTimeLabels()
def rmVolumeBars(self):
"""Ukrywa wykres wolumenu"""
if self.volumeBars==None:
return
self.volumeBars.set_visible(False)
self.fixPositions()
self.fixTimeLabels()
def setScaleType(self,type):
"""Ustawia skalę liniową lub logarytmiczną na głównym wykresie."""
if(type) not in ['linear','log']:
return
self.scaleType=type
self.updateMainPlot()
def updateVolumeBars(self):
"""Odświeża rysowanie wolumenu"""
if self.data==None or self.data.corrupted:
return
ax=self.volumeBars
ax.clear()
x=range(len(self.data.close))
ax.vlines(x,0,self.data.volume)
ax.set_xlim(x[0],x[-1])
if(max(self.data.volume)>0):
ax.set_ylim(0,1.2*max(self.data.volume))
for label in self.volumeBars.get_yticklabels():
label.set_visible(False)
for o in ax.findobj(Text):
o.set_visible(False)
self.formatDateAxis(ax)
self.fixTimeLabels()
def drawCandlePlot(self):
"""Wyświetla główny wykres w postaci świecowej"""
if self.data==None or self.data.corrupted:
return
ax=self.mainPlot
rectsList=[]
open=self.data.open
close=self.data.close
xvals=range(len(close))
lines=ax.vlines(xvals,self.data.low,self.data.high,label=self.data.name,linewidth=0.5)
lines.set_zorder(lines.get_zorder()-1)
for i in xvals:
height=max(abs(close[i]-open[i]),0.001)
width=0.7
x=i-width/2
y=min(open[i],close[i])
print x,y,width,height
if open[i]<=close[i]:
rectsList.append(Rectangle((x,y),width,height,facecolor='w',edgecolor='k',linewidth=0.5))
else:
rectsList.append(Rectangle((x,y),width,height,facecolor='k',edgecolor='k',linewidth=0.5))
ax.add_collection(PatchCollection(rectsList,match_original=True))
def drawBarPlot(self):
"""Rysuje główny wykres w postaci barowej."""
if self.data==None or self.data.corrupted:
return
ax=self.mainPlot
x=range(len(self.data.close))
lines1=ax.vlines(x,self.data.low,self.data.high,label=self.data.name)
lines2list=[]
for i in x:
lines2list.append(((i-0.3,self.data.open[i]),(i,self.data.open[i])))
lines2list.append(((i,self.data.close[i]),(i+0.3,self.data.close[i])))
lines2=LineCollection(lines2list)
lines2.color('k')
ax.add_collection(lines2)
def setMainIndicator(self, type):
"""Ustawiamy, jaki wskaźnik chcemy wyświetlać na głównym wykresie"""
self.mainIndicator=type
self.updateMainPlot()
def updateMainIndicator(self):
"""Odrysowuje wskaźnik na głównym wykresie"""
if self.data==None or self.data.corrupted:
return
ax=self.mainPlot
type=self.mainIndicator
ax.hold(True) #hold on
x=range(len(self.data.close))
if type=='SMA':
indicValues=self.data.movingAverage('SMA')
elif type=='WMA':
indicValues=self.data.movingAverage('WMA')
elif type=='EMA':
indicValues=self.data.movingAverage('EMA')
elif type=='bollinger':
if self.data.bollinger('upper')!=None:
ax.plot(x,self.data.bollinger('upper'),'r-',label=type)
indicValues=self.data.bollinger('lower')
else:
ax.hold(False)
return
if indicValues!=None:
ax.plot(x,indicValues,'r-',label=type)
ax.hold(False) #hold off
def setOscPlot(self, type):
"""Dodaje pod głównym wykresem wykres oscylatora danego typu lub ukrywa"""
if type not in ['momentum','CCI','RSI','ROC','williams']:
"""Ukrywa wykres oscylatora"""
if self.oscPlot==None:
return
self.oscPlot.set_visible(False)
self.fixPositions()
self.fixTimeLabels()
else:
self.oscType=type
if self.oscPlot==None:
oscBounds=[self.margin, self.margin, self.maxSize, self.oscHeight]
self.oscPlot=self.fig.add_axes(oscBounds, sharex=self.mainPlot)
self.updateOscPlot()
self.oscPlot.set_visible(True)
self.fixPositions()
self.fixTimeLabels()
def updateOscPlot(self):
"""Odrysowuje wykres oscylatora"""
if self.oscPlot==None or self.data.corrupted:
return
ax=self.oscPlot
type=self.oscType
ax.clear()
if type == 'momentum':
oscData=self.data.momentum()
elif type == 'CCI':
oscData=self.data.CCI()
elif type == 'ROC':
oscData=self.data.ROC()
elif type == 'RSI':
oscData=self.data.RSI()
elif type == 'williams':
oscData=self.data.williams()
elif type == 'TRIN':
oscData=self.data.TRIN()
elif type == 'mcClellan':
oscData=self.data.mcClellan()
elif type == 'adLine':
oscData=self.data.adLine()
else:
return
if oscData!=None:
x=range(len(self.data.close))
ax.plot(x,oscData,'g-',label=type)
ax.set_xlim(x[0],x[-1])
#legenda
leg = ax.legend(loc='best', fancybox=True)
leg.get_frame().set_alpha(0.5)
self.formatDateAxis(self.oscPlot)
self.fixOscLabels()
self.fixTimeLabels()
def fixOscLabels(self):
"""Metoda ustawia zakres osi poprawny dla danego oscylatora. Ponadto przenosi
etykiety na prawą stronę, żeby nie nachodziły na kurs akcji"""
ax=self.oscPlot
type=self.oscType
if type == 'ROC':
ax.set_ylim(-100, 100)
elif type == 'RSI':
ax.set_ylim(0, 100)
ax.set_yticks([30,70])
elif type == 'williams':
ax.set_ylim(-100,0)
for tick in ax.yaxis.get_major_ticks():
tick.label1On = False
tick.label2On = True
tick.label2.set_size(7)
def formatDateAxis(self,ax):
"""Formatuje etykiety osi czasu."""
chartWidth=int(self.fig.get_figwidth()*self.fig.get_dpi()*self.maxSize)
t = TextPath((0,0), '9999-99-99', size=7)
labelWidth = int(t.get_extents().width)
num_ticks=chartWidth/labelWidth/2
length=len(self.data.date)
if(length>num_ticks):
step=length/num_ticks
else:
step=1
x=range(0,length,step)
ax.xaxis.set_major_locator(FixedLocator(x))
ticks=ax.get_xticks()
labels=[]
for i, label in enumerate(ax.get_xticklabels()):
label.set_size(7)
index=int(ticks[i])
if(index>=len(self.data.date)):
labels.append('')
else:
labels.append(self.data.date[index].strftime("%Y-%m-%d"))
label.set_horizontalalignment('center')
ax.xaxis.set_major_formatter(FixedFormatter(labels))
def fixTimeLabels(self):
"""Włącza wyświetlanie etykiet osi czasu pod odpowiednim (tzn. najniższym)
wykresem, a usuwa w pozostałych"""
#oscylator jest zawsze na samym dole
if self.oscPlot!=None and self.oscPlot.get_visible():
for label in self.mainPlot.get_xticklabels():
label.set_visible(False)
for label in self.volumeBars.get_xticklabels():
label.set_visible(False)
for label in self.oscPlot.get_xticklabels():
label.set_visible(True)
#jeśli nie ma oscylatora to pod wolumenem
elif self.volumeBars!=None and self.volumeBars.get_visible():
for label in self.mainPlot.get_xticklabels():
label.set_visible(False)
for label in self.volumeBars.get_xticklabels():
label.set_visible(True)
#a jak jest tylko duży wykres to pod nim
else:
for label in self.mainPlot.get_xticklabels():
label.set_visible(True)
def fixPositions(self):
"""Dopasowuje wymiary i pozycje wykresów tak żeby zawsze wypełniały całą
przestrzeń. Główny wykres puchnie albo się kurczy, a wolumen i oscylator
przesuwają się w górę lub dół."""
#na początek wszystko spychamy na sam dół
mainBounds=[self.margin, self.margin, self.maxSize, self.maxSize]
volBounds=[self.margin, self.margin, self.maxSize, self.volHeight]
oscBounds=[self.margin, self.margin, self.maxSize, self.oscHeight]
#oscylator wypycha wolumen w górę i kurczy maina
if self.oscPlot!=None and self.oscPlot.get_visible():
mainBounds[1]+=self.oscHeight
mainBounds[3]-=self.oscHeight
volBounds[1]+=self.oscHeight
self.oscPlot.set_position(oscBounds)
#wolumen kolejny raz kurczy maina
if self.volumeBars.get_visible():
mainBounds[1]+=self.volHeight
mainBounds[3]-=self.volHeight
self.volumeBars.set_position(volBounds)
self.mainPlot.set_position(mainBounds)
def setDrawingMode(self, mode):
"""Włączamy (True) lub wyłączamy (False) tryb rysowania po wykresie"""
self.drawingMode=mode
self.x0, self.y0 = None,None
def drawLine(self, x0, y0, x1, y1, color='black', lwidth = 1.0, lstyle = '-'):
"""Rysuje linie (trend) na wykresie """
newLine=Line2D([x0,x1],[y0,y1], linewidth = lwidth, linestyle=lstyle, color=color)
self.mainPlot.add_line(newLine)
self.additionalLines.append(newLine)
newLine.figure.draw_artist(newLine)
self.blit(self.mainPlot.bbox) #blit to taki redraw
def clearLines(self):
"""Usuwa wszystkie linie narysowane dodatkowo na wykresie (tzn. nie kurs i nie wskaźniki)"""
for line in self.additionalLines:
line.remove()
self.additionalLines = []
self.draw()
self.blit(self.mainPlot.bbox)
def clearLastLine(self):
"""Usuwa ostatnią linię narysowaną na wykresie."""
if self.additionalLines==[]:
return
self.additionalLines[-1].remove()
self.additionalLines.remove(self.additionalLines[-1])
self.draw()
self.blit(self.mainPlot.bbox)
def drawRectangle(self, x, y, width, height, colour='blue', lwidth = 2.0, lstyle = 'dashed'):
"""Zaznacza prostokątem lukę/formację świecową czy coś tam jeszcze"""
newRect=Rectangle((x,y),width,height,facecolor='none',edgecolor=colour,linewidth=lwidth,linestyle=lstyle)
self.mainPlot.add_patch(newRect)
self.rectangles.append(newRect)
newRect.figure.draw_artist(newRect)
self.blit(self.mainPlot.bbox) #blit to taki redraw
def clearRectangles(self):
"""Usuwa prostokąty"""
for rect in self.rectangles:
rect.remove()
self.rectangles = []
self.draw()
self.blit(self.mainPlot.bbox)
def onClick(self, event):
"""Rysujemy linię pomiędzy dwoma kolejnymi kliknięciami."""
if self.drawingMode==False:
return
if event.button==3:
self.clearLastLine()
if event.button==2:
self.clearLines()
elif event.button==1:
if self.x0==None or self.y0==None :
self.x0, self.y0 = event.xdata, event.ydata
self.firstPoint=True
else:
x1, y1 = event.xdata, event.ydata
self.drawLine(self.x0,self.y0,x1,y1)
self.x0, self.y0 = None,None
def drawTrend(self):
self.clearLines()
a, b = trend.regression(self.data.close)
trend.optimizedTrend(self.data.close)
#self.drawTrendLine(0, b, len(self.data.close)-1, a*(len(self.data.close)-1) + b, 'y', 2.0)
sup, res = trend.getChannelLines(self.data.close)
self.drawLine(sup[0][1], sup[0][0], sup[len(sup)-1][1], sup[len(sup)-1][0], 'g')
self.drawLine(res[0][1], res[0][0], res[len(res)-1][1], res[len(res)-1][0], 'r')
if len(self.data.close) > 30:
sup, res = trend.getChannelLines(self.data.close, 1, 2)
self.drawLine(sup[0][1], sup[0][0], sup[len(sup)-1][1], sup[len(sup)-1][0], 'g', 2.0)
self.drawLine(res[0][1], res[0][0], res[len(res)-1][1], res[len(res)-1][0], 'r', 2.0)
class MatplotlibWidget(FigureCanvas):
"""Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
def __init__(self, parent=None, name=None, width=5, height=4, dpi=100,
bgcolor=None):
QtGui.QWidget.__init__(self, parent)
self.parent = parent
self.fig = Figure(figsize=(width, height), dpi=dpi,
facecolor=bgcolor, edgecolor=bgcolor)
FigureCanvas.__init__(self, self.fig)
self.setParent(parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.updateGeometry()
def sizeHint(self):
w = self.fig.get_figwidth()*self.fig.get_dpi()
h = self.fig.get_figheight()*self.fig.get_dpi()
return QtCore.QSize(w, h)
@QtCore.pyqtSlot()
def clear(self):
''' Clears the figure. '''
self.fig.clear()
@QtCore.pyqtSlot()
def reset(self):
'''
Clears the figure and prepares a new plot.
The difference between this and clear() is that
the latter only clears the figure, while this
also prepares the canvas for the plot commands.
'''
self.clear()
self.axes = self.fig.add_subplot(111)
self.axes.hold(False) # We want the axes cleared every time plot() is called
@QtCore.pyqtSlot (wave.Wave)
def plot1d (self, data, redraw=True):
'''
Called to plot the specified wave. It will be passed
to matplotlib's plot() as it is. This typically means
that if it's a higher-D matrix, it will be plotted as a
series of 1D graphs.
'''
w = wave.WCast(data)
self.axes.plot(w.dim[0].range, w)
if redraw == True:
self.draw()
@QtCore.pyqtSlot (wave.Wave)
def plot2d (self, data, redraw=True):
'''
Called to plot the specified 2D wave. Uses matplotlib's
imshow() to show the specified image.
'''
self.axes.imshow(data, aspect='auto', extent=wave.WCast(data).imlim)
if redraw == True:
self.draw()
@QtCore.pyqtSlot(wave.Wave)
def plot(self, data, redraw=True):
'''
Convenience wrapper for plot1d() or plot2d().
Assuming that 'data' is one single Wave (or ndarray object),
it calls plot1d() or plot2d(), depending on the dimensionality
of the data.
'''
if hasattr(data, '__iter__') and not hasattr(data, 'ndim'):
data_list = data
data = data_list[0]
if not hasattr(data, 'ndim'):
log.error ("Don't know how to plot data type: %s" % data)
return
if data.ndim == 1:
self.plot1d(data, redraw)
elif data.ndim == 2:
self.plot2d(data, redraw)
else:
self.axes.clear()
w = data.view(wave.Wave)
axinfo_str = ''.join([ ("axis %d: %f...%f (units: '%s')\n"
% (j, i.offset, i.end, i.units))
for i,j in zip(w.dim, range(w.ndim))])
self.axes.text (0.05, 0.95, "Don't know how to display wave!\n\nname: "
"%s\ndimensions: %d\n%s\n%s" %
(w.infs('name'), w.ndim, axinfo_str, pprint.pformat(w.info)),
transform=self.axes.transAxes, va='top')
self.draw()
class MyPlot(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self,parent, -1)
self.fig = None
self.canvas = None
self.ax = None
self.background = None
self.lines = []
self._doRePlot = True
self.foo = 1
self.t = time.time()
self.blit_time=0
self.y = numpy.cos(numpy.arange(0.0,1.0,0.1))
self.ylim = None
self.autolim = None
self.span = 500
self.begin = 0
self.channels = []
self._SetSize()
self.Bind(wx.EVT_IDLE, self._onIdle)
self.Bind(wx.EVT_SIZE, self._onSize)
self._resizeFlag = True
sizer=wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas,1,wx.GROW)
self.SetSizer(sizer)
self.canvas.Show()
def addChannel(self, channel):
self.channels.append(channel)
def setTimespan(self, span):
self.span = span
def setYlim(self, ymin, ymax):
self.ylim = [ymin, ymax]
def _resizeCreateContent(self):
'''Resize graph according to user input and initialize plots'''
self.lines=[]
for c in self.channels:
data=c.getNext()
line, = self.ax.plot(data[0],data[1], animated = True)
self.lines.append(line)
gca = self.fig.gca()
#TODO: add an auto mode here
if self.ylim:
gca.set_ylim(self.ylim)
else:
if self.autolim:
diff = self.autolim[1] - self.autolim[0]
gca.set_ylim([self.autolim[0] - 0.1*diff, self.autolim[1] + 0.1*diff])
else:
gca.set_ylim([-1,1])
gca.set_xlim([self.begin, (self.begin+self.span)])
self.ax.grid()
#self.fig.clear()
self.canvas.draw()
self.background = None
print 'content'
self._doRePlot = False
def _createGraphics(self):
"""Reallocate new figure and take care of panel resizing issues"""
self.fig=Figure()
self.canvas=FigureCanvas(self,-1,self.fig)
self.ax = self.fig.add_subplot(111)
self.ax._cachedRenderer=self.canvas.get_renderer()
def _onSize(self, evt):
self._resizeFlag = True
def _onIdle(self, event):
event.RequestMore(True)
if self._resizeFlag:
self._resizeFlag = False
self._SetSize()
self.draw_plot()
#if self.foo > 2000:
#u=time.time()
#print self.foo/(u-self.t), self.blit_time/(u-self.t)
#exit(0)
def _SetSize(self, pixels=None):
if not pixels:
pixels = self.GetClientSize()
self._createGraphics()
self.canvas.SetSize(pixels)
self.fig.set_size_inches(pixels[0]/self.fig.get_dpi(),
pixels[1]/self.fig.get_dpi(), forward=True)
self._doRePlot = True
def draw_plot(self):
if self._doRePlot:
self._resizeCreateContent()
if self.background is None:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
self.foo += 1
#self.y = numpy.cos(numpy.arange(0.0,1.0,0.1)+self.foo*0.1)
# Optimization on the blitting: we compute the box where the changes happen
changes_box = None
for i in range(len(self.lines)):
data=self.channels[i].getNext()
if len(data[1])>0:
if self.autolim:
print self.autolim[0], data[1], self.autolim[1]
self.autolim = [ min(self.autolim[0], min(data[1])), \
max(self.autolim[1], max(data[1])) ]
else:
self.autolim = [ min(data[1]), min(data[1]) ]
if changes_box is None:
changes_box = Bbox.unit()
print '>>>>>>>>'
print data[0], data[1]
changes_box.update_from_data(numpy.array(data[0]), \
numpy.array(data[1]), ignore=changes_box.is_unit())
if not self._doRePlot and len(data[0]) > 0 :
end = data[0][-1]
if end > self.begin+self.span:
self.begin += self.span
self._doRePlot = True
print 'do replot'
self.lines[i].set_data(data[0], data[1])
else:
self.lines[i].set_data([], [])
if not changes_box:
return
#self.canvas.restore_region(self.background)
for line in self.lines:
self.ax.draw_artist(line)
#print line.get_transform()
tr = line.get_transform()
changes_box_inframe = changes_box.transformed(tr)
box_padding = 5
(x,y,l,w) = changes_box_inframe.bounds
changes_box_inframe = Bbox.from_bounds(x-box_padding, \
y-box_padding, l+2*box_padding, w+2*box_padding)
#print
t0 = time.time()
self.canvas.blit(None)
#self.canvas.blit(changes_box_inframe)
self.blit_time += time.time() - t0
