def run(self, results):
par = self.getValueOfParameter("parameter")
i = int(self.getValueOfParameter("iteration number"))
title = self.getValueOfParameter("title")
if(par==""):
return False
if(i >= results.__len__()):
return False
dialogform = Dialog(QApplication.activeWindow())
fig = Figure((5.0, 4.0), dpi=100)
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
for n in ["top", "right"]:
ax.axis[n].set_visible(False)
for n in ["bottom", "left"]:
ax.axis[n].set_visible(True)
x = results[i].getResults(par)
if(not(x.__len__())):
return False
ax.boxplot(x, notch=0, sym='+', vert=1, whis=1.5)
ax.set_title(title)
dialogform.showFigure(fig)
return True
def _blank_plot(domain, ran):
# make the plot
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
# thicken the axis lines
ax.axhline(linewidth=1.7, color="k")
ax.axvline(linewidth=1.7, color="k")
x_lower, x_upper = int(domain.left), int(
domain.right) # needs to be changed, is just a temporary type changer
y_lower, y_upper = int(ran.left), int(ran.right)
# remove tick lines on the axes
plt.xticks([])
plt.yticks([])
plt.ylim(y_lower, y_upper)
plt.xlim(x_lower, x_upper)
# add axes labels
ax.text(1.05,
0,
r'$x$',
transform=BlendedGenericTransform(ax.transAxes, ax.transData),
va='center')
ax.text(0,
1.05,
r'$y$',
transform=BlendedGenericTransform(ax.transData, ax.transAxes),
ha='center')
# end-of-axis arrows
x_width = (abs(plt.xlim()[0]) + abs(plt.xlim()[1]))
y_width = (abs(plt.ylim()[0]) + abs(plt.ylim()[1]))
plt.arrow(plt.xlim()[1],
-0.003,
0.00000000001,
0,
width=x_width * 0.0015 * 0.5,
color="k",
clip_on=False,
head_width=y_width * 0.12 / 7,
head_length=x_width * 0.024 * 0.5)
plt.arrow(0.003,
plt.ylim()[1],
0,
0.00000000001,
width=y_width * 0.0015 * 0.5,
color="k",
clip_on=False,
head_width=x_width * 0.12 / 7,
head_length=y_width * 0.024 * 0.5)
# only show cartesian axes
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
def __init__(self):
self.fig = plt.figure(1)
self.ax = SubplotZero(self.fig,111)
self.fig.add_subplot(self.ax)
for direction in ["xzero","yzero"]:
self.ax.axis[direction].set_axisline_style("-|>")
self.ax.axis[direction].set_visible(True)
for direction in ["left","right","bottom","top"]:
self.ax.axis[direction].set_visible(False)
def make_zerocross_axes(figsize, loc):
fig = plt.figure(figsize=figsize)
ax = SubplotZero(fig, loc)
ax.set_aspect("equal")
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
axis = ax.axis[direction]
axis.set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
return ax
def tell_winner(self, winner, *args):
if self.show_text:
print winner, "has won the game!"
if not self.run_trials: return
if self.graph:
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.suptitle("Winrate of %s over time"%(self.stats.keys()[0]))
fig.add_subplot(ax)
ax.plot(self.stats.values()[0])
plt.show()
print self.stats.values()[0]
def plot(points):
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
plt.ylim([-10, 10])
plt.xlim([-10, 10])
ax.plot(*zip(*points), marker='o', color='r', ls='')
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
plt.show()
def test_m_n_computation(obj_img, theta, Nx, Ny, dx, dy, Nt, Nr, dr):
bx = -Nx/2 * dx
by = -Ny/2 * dy
xmin = -(Nx-1)/2.0*dx
ymin = -(Ny-1)/2.0*dy
legend_list = []
fig = plt.figure(figsize=(8,8))
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
plt.imshow(obj_img, cmap=plt.cm.gray, interpolation='none', \
extent=[bx,-bx, by, -by], alpha=0.5)
for t in np.arange(Nr):
if np.sin(theta) < 1.0/np.sqrt(2):
data = test_n_computation(theta, t, Nx, Ny, dx, dy, Nt, Nr, dr)
else:
data = test_m_computation(theta, t, Nx, Ny, dx, dy, Nt, Nr, dr)
#rdata = np.round(data)
plt.plot(data[0,:]*dx+xmin, data[1,:]*dy+ymin,'*-', linewidth = 3 )
legend_list.append('(t=' + str(t) + ')')
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
ax.xaxis.set_ticks(np.arange(-Nx,Nx,2))
ax.yaxis.set_ticks(np.arange(-Ny,Ny,2))
plt.axis('equal')
plt.grid(True)
plt.legend(legend_list)
plt.title('Angle: ' + str(theta*180/np.pi))
def plot_func(a, b, c, out_putline):
'''Plot the line function in a coordinate axis
Parameters:
a -- The coefficient for y in the standard for Ay + Bx = C
b -- The coefficient for x in the standard for Ay + Bx = C
c -- The constanct C in the standard for Ay + Bx = C
out_putline -- The string of the standard form Ay + Bx = C
'''
# Unable to plot if the coefficient of x or y equals to 0
if b == 0:
sys.stderr.write('Unable to plot a vertical line!!!\n')
sys.exit(1)
if a == 0:
sys.stderr.write('Unable to plot a horizontal line!!!\n')
sys.exit(1)
# General steps to generate an axis
try:
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
except Exception, e:
sys.stderr.write('Unable to use matplotlib!!!\n')
sys.exit(1)
def test():
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
x = np.linspace(-0.5, 1., 100)
ax.plot(x, np.sin(x * np.pi))
plt.show()
def setup_two_axes_subplot(fig, m, n, curr_plot_num, invisible=["bottom", "top", "right"]):
ax = SubplotZero(fig, m, n, curr_plot_num)
fig.add_subplot(ax)
ax.axis["xzero"].set_visible(True)
for n in invisible:
ax.axis[n].set_visible(False)
return ax
def make_zerocross_axes(figsize, loc):
from matplotlib import pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
fig = plt.figure(figsize=figsize)
ax = SubplotZero(fig, loc)
ax.set_aspect("equal")
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
axis = ax.axis[direction]
axis.set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
return ax
def plot_L(self):
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for el in self.L:
self.plot_box(X=el, index=0, this_color='blue', canvas=ax)
ax.set_xlim(-15., 15.)
ax.set_ylim(-15., 15.)
ax.axis('equal')
plt.show()
def plotAxis(self, matrix):
#funct = gvbars(delta=0.05, color=color.blue)
#for i in range(0, len(matrix[0])):
# funct.plot(pos=(0,matrix[0][i]))
#pylab.scatter(3,4, s=100 ,marker='o', c=color.green)
#pylab.show()
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
flattenMatrix = np.transpose(matrix).flatten()
x = np.linspace(0., 10., len(flattenMatrix))
print 'x ' + str(x)
print 'matrix: ' + str(np.transpose(matrix).flatten())
#ax.plot(x, np.sin(x*np.pi), linewidth=2.0)
ax.plot(matrix, 0, linewidth=2.0)
plt.show()
def make_zerocross_axes(figsize, loc):
from matplotlib import pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
fig = plt.figure(figsize=figsize)
ax = SubplotZero(fig, loc)
ax.set_aspect("equal")
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
axis = ax.axis[direction]
axis.set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
return ax
def make_plot_ax():
fig = figure(figsize=(6, 5));
ax = SubplotZero(fig, 111); fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
xlim(-0.1, 2.1); ylim(xlim())
ticks = [0.5 * i for i in range(1, 5)]
labels = [str(i) if i == int(i) else "" for i in ticks]
ax.set_xticks(ticks); ax.set_yticks(ticks)
ax.set_xticklabels(labels); ax.set_yticklabels(labels)
ax.axis["yzero"].set_axis_direction("left")
return ax
def subplots():
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
return fig, ax
def make_plot_ax():
fig = figure(figsize=(6, 5))
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
xlim(-0.1, 2.1)
ylim(xlim())
ticks = [0.5 * i for i in range(1, 5)]
labels = [str(i) if i == int(i) else "" for i in ticks]
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(labels)
ax.set_yticklabels(labels)
ax.axis["yzero"].set_axis_direction("left")
return ax
def run(self, results):
par1 = self.getValueOfParameter("parameter 1")
par2 = self.getValueOfParameter("parameter 2")
title = self.getValueOfParameter("title")
if(par1==""):
return False
if(par2==""):
return False
x = pycalimero.doublevector();
y = pycalimero.doublevector();
for i in results:
x.append(i.getResults(par1)[0])
y.append(i.getResults(par2)[0])
dialogform = Dialog(QApplication.activeWindow())
fig = Figure((5.0, 4.0), dpi=100)
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
for n in ["top", "right"]:
ax.axis[n].set_visible(False)
for n in ["bottom", "left"]:
ax.axis[n].set_visible(True)
if(not(x.__len__())):
return False
if(not(y.__len__())):
return False
ax.plot (x, y, '.')
ax.set_title(title)
dialogform.showFigure(fig)
return True
def graphWaveSamples(samples):
y = [struct.unpack('h', i)[0] for i in samples]
#print y
print "max:", max(y)
print "min:", min(y)
print "avg:", sum(y)/float(len(y))
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
x = range(len(y))
ax.plot(x, y)
plt.show()
def plotUnitCircle(p):
""" plot some 2D vectors with p-norm < 1 """
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
x = np.linspace(-1.0, 1.0, 1000)
y = np.linspace(-1.0, 1.0, 1000)
X, Y = np.meshgrid(x, y)
F = (((abs(X) ** p + abs(Y) ** p) ** (1.0 / p)) - 1)
ax.contour(X, Y, F, [0])
plt.savefig('UnitCircle.pdf', facecolor='w', edgecolor='w',
papertype=None, format='pdf', transparent=False,
bbox_inches='tight', pad_inches=0.1)
plt.show()
def plot_subpaving(self):
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for el in self.outside:
self.plot_box(X=el, index=0, this_color='red', canvas=ax)
for el in self.boundary:
self.plot_box(X=el, index=0, this_color='yellow', canvas=ax)
for el in self.inside:
self.plot_box(X=el, index=0, this_color='green', canvas=ax)
ax.set_xlim(-12., 12.)
ax.set_ylim(-12., 12.)
ax.axis('equal')
plt.show()
return
def setup_two_axes(fig, labelpad=1, invisible=["bottom", "top", "right"]):
plt.rcParams['xtick.major.pad'] = 0.1
plt.rcParams['xtick.minor.pad'] = 0.1
plt.rcParams['ytick.major.pad'] = 2
plt.rcParams['ytick.minor.pad'] = 2
ax = SubplotZero(fig, 1, 1, 1)
ax.yaxis.labelpad = labelpad
fig.add_subplot(ax)
# make xzero axis (horizontal axis line through y=0) visible.
ax.axis["xzero"].set_visible(True)
ax.xaxis.labelpad = labelpad
# make other axis (bottom, top, right) invisible.
for n in invisible:
ax.axis[n].set_visible(False)
return ax
def run(self, results):
par1 = self.getValueOfParameter("parameter 1")
par2 = self.getValueOfParameter("parameter 2")
i = int(self.getValueOfParameter("iteration number"))
title = self.getValueOfParameter("title")
if(par1==""):
return False
if(par2==""):
return False
if(i >= results.__len__()):
return False
dialogform = Dialog(QApplication.activeWindow())
fig = Figure((5.0, 4.0), dpi=100)
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
for n in ["top", "right"]:
ax.axis[n].set_visible(False)
for n in ["bottom", "left"]:
ax.axis[n].set_visible(True)
y1 = results[i].getResults(par1)
y2 = results[i].getResults(par2)
if(not(y1.__len__())):
return False
if(not(y2.__len__())):
return False
ax.plot(range(0,y1.__len__()),y1,color='r')
ax.plot(range(0,y2.__len__()),y2,color='b')
ax.set_title(title)
leg = ax.legend((par1, par2),
'upper center', shadow=True)
frame = leg.get_frame()
frame.set_facecolor('0.80') # set the frame face color to light gray
# matplotlib.text.Text instances
for t in leg.get_texts():
t.set_fontsize('small') # the legend text fontsize
# matplotlib.lines.Line2D instances
for l in leg.get_lines():
l.set_linewidth(1.5) # the legend line width
dialogform.showFigure(fig)
return True
def test_min_max_plane_indices(obj_img, Nx, Ny, dx, dy, Nt, Nr, dr):
bx = -Nx / 2 * dx
by = -Ny / 2 * dy
fovx = Nx * dx
fovy = Ny * dy
r = np.ceil(np.sqrt((fovx)**2 + (fovy)**2))
xc = dx / 2
yc = -dy / 2
sdd = 2 * r
p1x = np.zeros(Nt, dtype=TYPE)
p1y = np.zeros(Nt, dtype=TYPE)
p2x = np.zeros(Nt, dtype=TYPE)
p2y = np.zeros(Nt, dtype=TYPE)
for angle in np.arange(Nt):
text = ''
legend_list = []
fig = plt.figure(figsize=(8, 8))
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
plt.imshow(obj_img, cmap=plt.cm.gray, interpolation='none', \
extent=[bx,-bx, by, -by], alpha=0.5)
for t in np.arange(-Nr / 2, Nr / 2):
# find p1-detector and p2-source coordinates
p1x[angle], p1y[angle] = get_p1(angle * np.pi / Nt, t, r, xc, yc,
dr)
p2x[angle], p2y[angle] = get_p2(angle*np.pi/Nt, sdd, p1x[angle], \
p1y[angle])
plt.plot( [p1x[angle], p2x[angle]] ,[p1y[angle], p2y[angle]], ':',\
linewidth = 3 )
imin, imax, jmin, jmax = min_max_plane_indices(Nx, Ny, \
p1x[angle], p1y[angle], p2x[angle], p2y[angle], bx, by, dx, dy)
text += '(t=' + str(t) + ') imin:' + str(imin) + ', imax:' + \
str(imax) + ' ,jmin:' + str(jmin) + ' ,jmax:' + \
str(jmax) + '\n'
legend_list.append('(t=' + str(t) + ')')
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
ax.xaxis.set_ticks(np.arange(-Nx, Nx, 2))
ax.yaxis.set_ticks(np.arange(-Ny, Ny, 2))
plt.axis('equal')
plt.grid(True)
plt.legend(legend_list)
plt.title(text, fontsize=10)
def open_window_and_show_results(points, curve, bezier_points):
# Generate the curve
curve_begin = min(points, key=lambda p: p.x)
curve_end = max(points, key=lambda p: p.x)
curve_begin = floor(curve_begin.x)
curve_end = ceil(curve_end.x)
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
curve_points = []
if (len(curve) == 3):
curve_points = generate_curve_points_quadratic(
[x * 0.1 for x in range(curve_begin * 10, curve_end * 10)],
curve[0], curve[1], curve[2]) # values for x²
elif (len(curve) == 4):
curve_points = generate_curve_points_cubic(
[x * 0.1 for x in range(curve_begin * 10, curve_end * 10)],
curve[0], curve[1], curve[2], curve[3]) # values for x²
else:
raise "Length of curve has to be 3 or 4"
# plot_points(plt, curve_points, 'blue')
# plot_points(plt, points, 'ro')
plot_points(plt, points, 'red')
plot_points(plt, bezier_points, 'go')
plot_points(
plt,
draw_bezier_curve(bezier_points[0], bezier_points[1], bezier_points[2],
bezier_points[3]), 'orange')
plt.show()
def plot_points_helper(x, y, x_poly, y_poly, scale_plot=True):
figure = plt.figure(figsize=(12, 8))
ax = SubplotZero(figure, 111)
figure.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
scale = np.mean(x[x > 0]) + np.mean(y[y > 0]) if scale_plot else 0
plt.xlim([min(x) - scale, max(x) + scale])
plt.ylim([min(y) - scale, max(y) + scale])
plt.scatter(x, y)
plt.plot(x_poly, y_poly, color='r')
plt.show()
def initplot(size):
"""
Inicializa o desenho de gráficos.
"""
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
ax.set_xlim(-10, size)
ax.set_ylim(-10, size)
return (fig, ax)
def _blank_plot(domain, ran):
# make the plot
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
# thicken the axis lines
ax.axhline(linewidth=1.7, color="k")
ax.axvline(linewidth=1.7, color="k")
x_lower, x_upper = int(domain.left), int(domain.right) # needs to be changed, is just a temporary type changer
y_lower, y_upper = int(ran.left), int(ran.right)
# remove tick lines on the axes
plt.xticks([])
plt.yticks([])
plt.ylim(y_lower, y_upper)
plt.xlim(x_lower, x_upper)
# add axes labels
ax.text(1.05, 0, r'$x$', transform=BlendedGenericTransform(ax.transAxes, ax.transData), va='center')
ax.text(0, 1.05, r'$y$', transform=BlendedGenericTransform(ax.transData, ax.transAxes), ha='center')
# end-of-axis arrows
x_width = (abs(plt.xlim()[0]) + abs(plt.xlim()[1]))
y_width = (abs(plt.ylim()[0]) + abs(plt.ylim()[1]))
plt.arrow(plt.xlim()[1], -0.003, 0.00000000001, 0,
width=x_width*0.0015*0.5, color="k", clip_on=False,
head_width=y_width*0.12/7, head_length=x_width*0.024*0.5)
plt.arrow(0.003, plt.ylim()[1], 0, 0.00000000001,
width=y_width*0.0015*0.5, color="k", clip_on=False,
head_width=x_width*0.12/7, head_length=y_width*0.024*0.5)
# only show cartesian axes
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
def create_plot(self, scale, y_bounds, points=None, file_name=None):
"""
Using matplotlib, graphs the given points on a Cartesian plane.
Adapted from the matplotlib documentation:
https://matplotlib.org/examples/axes_grid/demo_axisline_style.html.
args:
scale: Numpy array of increments for the x-axis.
points: Numpy array of points' Y-values to be plotted.
y_bounds: integer determining scale of y axis
file_name: name for plot to be serialized under.
"""
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
fig = plt.figure(1)
subplot = SubplotZero(fig, 111)
fig.add_subplot(subplot)
for direction in ['xzero', 'yzero']:
subplot.axis[direction].set_axisline_style('-|>')
subplot.axis[direction].set_visible(True)
for direction in ['left', 'right', 'bottom', 'top']:
subplot.axis[direction].set_visible(False)
subplot.set_ylim([-y_bounds, y_bounds])
if points is not None:
subplot.plot(scale, points)
if file_name:
plt.savefig(file_name)
else:
plt.show()
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
import numpy as np
fig = plt.figure(1, (4,3))
# a subplot with two additiona axis, "xzero" and "yzero". "xzero" is
# y=0 line, and "yzero" is x=0 line.
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
# make xzero axis (horizontal axis line through y=0) visible.
ax.axis["xzero"].set_visible(True)
ax.axis["xzero"].label.set_text("Axis Zero")
# make other axis (bottom, top, right) invisible.
for n in ["bottom", "top", "right"]:
ax.axis[n].set_visible(False)
xx = np.arange(0, 2*np.pi, 0.01)
ax.plot(xx, np.sin(xx))
plt.show()
##Input : the stress tensor
##Output : anmiation
# ########################
# INPUT : Stress tensor ! must be a plan stress state !
# ########################
Sigma = np.array([[400, 100, 0], [100, -200, 0], [0, 0, 0]], float)
print("Sigma=", Sigma)
# ########################
# Set up the figure, the axis, and the plot element we want to animate
# ########################
fig = plt.figure(1)
Sig_max = 500.0
# Espace x,y
ax1 = SubplotZero(fig, 121)
fig.add_subplot(ax1)
#
for direction in ["xzero", "yzero"]:
ax1.axis[direction].set_axisline_style("-|>")
ax1.axis[direction].set_visible(True)
#
for direction in ["left", "right", "bottom", "top"]:
ax1.axis[direction].set_visible(False)
ax1.set_aspect('equal')
ax1.set_xlim(-Sig_max, Sig_max)
ax1.set_ylim(-Sig_max, Sig_max)
ax1.text(0.,
1.05,
#!/usr/bin/env python3
from mpl_toolkits.axes_grid.axislines import SubplotZero
from matplotlib.transforms import BlendedGenericTransform
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
import numpy as np
if __name__ == '__main__':
fig = plt.figure(1)
ax = SubplotZero(fig, 1, 1, 1)
# fig.autofmt_xdate(bottom=0.2, rotation=30, ha='right')
fig.add_subplot(ax)
ax.text(-1.15, 0.99, 'y', transform=BlendedGenericTransform(ax.transData, ax.transAxes), ha='center')
ax.text(1., -0.25, 'x', transform=BlendedGenericTransform(ax.transAxes, ax.transData), va='center')
#
for direction in ["xzero", "left"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
x = np.linspace(-1., +1., 1000) # x < 0
# print(x)
def visualize_test_between_class(test, human, non_human):
fig = plt.figure("Trajectories for Test, Human, and Non-Human")
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
line_style = ['r.-', 'gx-', 'bo-']
# plotting test data
x = [i.pose.position.x for i in test]
y = [i.pose.position.y for i in test]
ax.plot(x, y, line_style[0], label="Test")
# plotting human data
x = [i.pose.position.x for i in human]
y = [i.pose.position.y for i in human]
ax.plot(x, y, line_style[1], label="Human")
# plotting non-human data
x = [i.pose.position.x for i in non_human]
y = [i.pose.position.y for i in non_human]
ax.plot(x, y, line_style[2], label="Non-human")
ax.margins(0.05)
ax.legend(loc="lower right", fontsize=10)
plt.title("Chunks of Trajectories")
plt.xlabel("Axis")
plt.ylabel("Ordinate")
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
pylab.grid()
plt.show()
def renderGraph(self): # pylint: disable=R0914
assert len(self._oData.aoSeries) == 1;
oSeries = self._oData.aoSeries[0];
# hacking
#self.setWidth(512);
#self.setHeight(128);
# end
oFigure = self._createFigure();
from mpl_toolkits.axes_grid.axislines import SubplotZero;
oAxis = SubplotZero(oFigure, 111);
oFigure.add_subplot(oAxis);
# Disable all the normal axis.
oAxis.axis['right'].set_visible(False)
oAxis.axis['top'].set_visible(False)
oAxis.axis['bottom'].set_visible(False)
oAxis.axis['left'].set_visible(False)
# Use the zero axis instead.
oAxis.axis['yzero'].set_axisline_style('-|>');
oAxis.axis['yzero'].set_visible(True);
oAxis.axis['xzero'].set_axisline_style('-|>');
oAxis.axis['xzero'].set_visible(True);
if oSeries.aoYValues[-1] == 100:
sColor = 'green';
elif oSeries.aoYValues[-1] > 75:
sColor = 'yellow';
else:
sColor = 'red';
oAxis.plot(oSeries.aoXValues, oSeries.aoYValues, '.-', color = sColor, linewidth = 3);
oAxis.fill_between(oSeries.aoXValues, oSeries.aoYValues, facecolor = sColor, alpha = 0.5)
oAxis.set_xlim(left = -0.01);
oAxis.set_xticklabels([]);
oAxis.set_xmargin(1);
oAxis.set_ylim(bottom = 0, top = 100);
oAxis.set_yticks([0, 50, 100]);
oAxis.set_ylabel('%');
#oAxis.set_yticklabels([]);
oAxis.set_yticklabels(['', '%', '']);
return self._produceSvg(oFigure, False);
def renderGraph(self): # pylint: disable=R0914
assert len(self._oData.aoSeries) == 1
oSeries = self._oData.aoSeries[0]
# hacking
# self.setWidth(512);
# self.setHeight(128);
# end
oFigure = self._createFigure()
from mpl_toolkits.axes_grid.axislines import SubplotZero
# pylint: disable=E0401
oAxis = SubplotZero(oFigure, 111)
oFigure.add_subplot(oAxis)
# Disable all the normal axis.
oAxis.axis["right"].set_visible(False)
oAxis.axis["top"].set_visible(False)
oAxis.axis["bottom"].set_visible(False)
oAxis.axis["left"].set_visible(False)
# Use the zero axis instead.
oAxis.axis["yzero"].set_axisline_style("-|>")
oAxis.axis["yzero"].set_visible(True)
oAxis.axis["xzero"].set_axisline_style("-|>")
oAxis.axis["xzero"].set_visible(True)
if oSeries.aoYValues[-1] == 100:
sColor = "green"
elif oSeries.aoYValues[-1] > 75:
sColor = "yellow"
else:
sColor = "red"
oAxis.plot(oSeries.aoXValues, oSeries.aoYValues, ".-", color=sColor, linewidth=3)
oAxis.fill_between(oSeries.aoXValues, oSeries.aoYValues, facecolor=sColor, alpha=0.5)
oAxis.set_xlim(left=-0.01)
oAxis.set_xticklabels([])
oAxis.set_xmargin(1)
oAxis.set_ylim(bottom=0, top=100)
oAxis.set_yticks([0, 50, 100])
oAxis.set_ylabel("%")
# oAxis.set_yticklabels([]);
oAxis.set_yticklabels(["", "%", ""])
return self._produceSvg(oFigure, False)
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
import numpy as np
filename = 'data/plot_exp1_1280.txt'
pair_list = [line.split() for line in open(filename)]
p = [float(pair[0]) for pair in pair_list]
probability = [float(pair[1]) for pair in pair_list]
if 1:
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
ax.axis['xzero'].set_label('p')
ax.axis['yzero'].set_label('probability that the path exists')
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
ax.plot(p, probability)
plt.show()
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>, size=2")
ax.axis[direction].set_visible(True)
ax.set_yticklabels([])
ax.set_xticklabels([])
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
ax.axis['xzero'].set_label('asdfsadf')
x = np.linspace(-10, 10, 1000)
ax.plot(x, np.sin(x*np.pi))
plt.show()
def renderGraph(self): # pylint: disable=R0914
assert len(self._oData.aoSeries) == 1
oSeries = self._oData.aoSeries[0]
# hacking
#self.setWidth(512);
#self.setHeight(128);
# end
oFigure = self._createFigure()
from mpl_toolkits.axes_grid.axislines import SubplotZero
# pylint: disable=E0401
oAxis = SubplotZero(oFigure, 111)
oFigure.add_subplot(oAxis)
# Disable all the normal axis.
oAxis.axis['right'].set_visible(False)
oAxis.axis['top'].set_visible(False)
oAxis.axis['bottom'].set_visible(False)
oAxis.axis['left'].set_visible(False)
# Use the zero axis instead.
oAxis.axis['yzero'].set_axisline_style('-|>')
oAxis.axis['yzero'].set_visible(True)
oAxis.axis['xzero'].set_axisline_style('-|>')
oAxis.axis['xzero'].set_visible(True)
if oSeries.aoYValues[-1] == 100:
sColor = 'green'
elif oSeries.aoYValues[-1] > 75:
sColor = 'yellow'
else:
sColor = 'red'
oAxis.plot(oSeries.aoXValues,
oSeries.aoYValues,
'.-',
color=sColor,
linewidth=3)
oAxis.fill_between(oSeries.aoXValues,
oSeries.aoYValues,
facecolor=sColor,
alpha=0.5)
oAxis.set_xlim(left=-0.01)
oAxis.set_xticklabels([])
oAxis.set_xmargin(1)
oAxis.set_ylim(bottom=0, top=100)
oAxis.set_yticks([0, 50, 100])
oAxis.set_ylabel('%')
#oAxis.set_yticklabels([]);
oAxis.set_yticklabels(['', '%', ''])
return self._produceSvg(oFigure, False)
horizontalalignment='center',
verticalalignment='center',
fontsize=16, fontweight='demibold',
transform=ax.transAxes)
plotting.remove_axis_junk(ax)
t = np.arange(p_net.shape[1])*PSET.dt*PSET.decimate_q
inds = (t >= T[0]) & (t <= T[1])
ax.plot(t[inds], p_net[i, inds], 'k', lw=1)
ax.set_ylabel(ylabel)
ax.set_xticklabels([])
# panel F. Illustration of 4-sphere volume conductor model geometry
ax = SubplotZero(fig, gs[2, 1])
fig.add_subplot(ax)
ax.set_title('four-sphere volume conductor model')
for direction in ["xzero"]:
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
theta = np.linspace(0, np.pi, 31)
# draw some circles:
for i, r, label in zip(range(4), PSET.foursphereParams['radii'], ['brain', 'CSF', 'skull', 'scalp']):
ax.plot(np.cos(theta)*r, np.sin(theta)*r, 'C{}'.format(i), label=label + r', $r_%i=%i$ mm' % (i+1, r / 1000), clip_on=False)
ax0.axis('off')
ax0.set_title('extracellular potential')
ax1 = fig.add_subplot(gs[:6, 1], aspect='equal') # dipole moment ill.
ax1.axis('off')
ax1.set_title('extracellular potential')
ax2 = fig.add_subplot(gs[:6, 2], aspect='equal') # dipole moment ill.
ax2.axis('off')
ax2.set_title('magnetic field')
# ax3 = fig.add_subplot(gs[0, 3], aspect='equal') # spherical shell model ill.
# ax3.set_title('4-sphere volume conductor')
# ax4 = fig.add_subplot(gs[1, 3],
# aspect='equal'
# ) # MEG/EEG forward model ill.
# ax4.set_title('EEG and MEG signal detection')
ax3 = SubplotZero(fig, gs[7:, 0])
fig.add_subplot(ax3)
ax3.set_title('4-sphere volume conductor', verticalalignment='bottom')
ax4 = fig.add_subplot(gs[7:, 1]) # EEG
ax4.set_title('scalp electric potential $\phi_\mathbf{p}(\mathbf{r})$')
ax5 = fig.add_subplot(gs[7:, 2], sharey=ax4) # MEG
# ax5.set_title('scalp magnetic field')
#morphology - line sources for panels A and B
zips = []
xz = cell.get_idx_polygons()
for x, z in xz:
zips.append(zip(x, z))
for ax in [ax0]:
polycol = PolyCollection(zips,
linewidths=(0.5),
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
import numpy as np
fig = plt.figure(1, (4, 3))
# a subplot with two additiona axis, "xzero" and "yzero". "xzero" is
# y=0 line, and "yzero" is x=0 line.
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
# make xzero axis (horizontal axis line through y=0) visible.
ax.axis["xzero"].set_visible(True)
ax.axis["xzero"].label.set_text("Axis Zero")
# make other axis (bottom, top, right) invisible.
for n in ["bottom", "top", "right"]:
ax.axis[n].set_visible(False)
xx = np.arange(0, 2 * np.pi, 0.01)
ax.plot(xx, np.sin(xx))
plt.show()
cur_x0 = cur_x0 + (cur_a1 - cur_x0) / (i + 2)
cur_x1 = cur_x1 + (cur_a0 - cur_x1) / (i + 2)
return x0s, x1s
def ficthist(t):
x0_last = []
for i in range(t):
x0s, x1s = fict(t)
x0_last.append(x0s[-1])
return x0_last
x0s, x1s = fict(t)
fig, ax = plt.subplots()
ax.plot(x0s, 'r-')
ax.plot(x1s, 'b-')
#plt.savefig('fictitious.png')
#plt.savefig('fictitious.pdf')
plt.show()
fig = plt.figure()
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
ax.hist(ficthist(t))
#plt.savefig('fictitious_hist.png')
#plt.savefig('fictitious_hist.pdf')
plt.show()
#klasyfikator
def classifier(x):
if g1(x) > g2(x):
return 1
else:
return 2
N = 10
x1 = 4 * np.random.randn(N, 2) + (-2)
x2 = 4 * np.random.randn(N, 2) + (+2)
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
ax.plot(x1[:, 0], x1[:, 1], 'yo', x2[:, 0], x2[:, 1], 'go')
ax.plot([-10, 10], [-10, 10])
data = np.vstack((x1, x2))
print(data)
# #wartości funkcji klasyfikujących
# y1=[g1(data[i,:]) for i in range(2*N)]
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
import numpy as np
import fractions
# 改変箇所をまとめておく
FIGNUM = 1 # 0 or 1
if FIGNUM == 0:
t_max, step = 2, fractions.Fraction(1,3) # 傾きの最大、最小値の設定
# 傾きをいくつ刻みで変化させるか。分数のまま計算させるためにFraction()を利用した
if FIGNUM == 1:
t_max, step = 3, fractions.Fraction(1,2)
x_max = 7
y_max = 6
y_min = -5
def f(x, t):
return t*x-t**2
# 以上が改変箇所
t_min = -t_max # 対称性の利用
x_min = -x_max
if 1:
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
p_delta_x = (b-a)/(pixel_h-20) #ancho del pixel
p_delta_y = (y_max-y_min)/(pixel_v-20) #largo del pixel
px = np.zeros(len(x_real))
py = np.zeros(len(y_real))
#Cómputo de las coordenadas en pantalla
for i in range(len(x_real)):
px[i] = (x_real[i]/p_delta_x)+10
for j in range(len(y)):
py[j]= ((y_max-y[j])/p_delta_y)+10
return px, py
z = coor_screen(x,y)
#Para proyectar figura
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direccion in ["xzero", "yzero"]:
ax.axis[direccion].set_axisline_style("-|>")
ax.axis[direccion].set_visible(True)
for direccion in ["left", "right", "bottom", "top"]:
ax.axis[direccion].set_visible(False)
ax.plot(z[0], z[1]-250) #Restamos 250 porque interpreta el origen del eje x en la parte superior de la pantalla
#TENER EN CUENTA QUE LOS LABELS EN LOS EJES SON LAS COORDENADAS EN PANTALLA
#∫∫∫∫∫∫∫∫savefig("grafica.png", dpi=72)
plt.show()
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
import numpy as np
filename = "data/exp2_1000.txt"
input = open(filename)
N = int(input.readline())
pair_list = [line.split() for line in input]
p = [float(pair[0]) / float(N ** 2) for pair in pair_list]
size = [float(pair[1]) for pair in pair_list]
if 1:
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
ax.axis["xzero"].set_label("p")
ax.axis["yzero"].set_label("size of largest component")
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
ax.plot(p, size)
plt.show()
ax0.axis('off')
ax0.set_title('extracellular potential')
ax1 = fig.add_subplot(gs[:6, 1], aspect='equal') # dipole moment ill.
ax1.axis('off')
ax1.set_title('extracellular potential')
ax2 = fig.add_subplot(gs[:6, 2], aspect='equal') # dipole moment ill.
ax2.axis('off')
ax2.set_title('magnetic field')
# ax3 = fig.add_subplot(gs[0, 3], aspect='equal') # spherical shell model ill.
# ax3.set_title('4-sphere volume conductor')
# ax4 = fig.add_subplot(gs[1, 3],
# aspect='equal'
# ) # MEG/EEG forward model ill.
# ax4.set_title('EEG and MEG signal detection')
ax3 = SubplotZero(fig, gs[7:, 0])
fig.add_subplot(ax3)
ax3.set_title('4-sphere volume conductor', verticalalignment='bottom')
ax4 = fig.add_subplot(gs[7:, 1]) # EEG
ax4.set_title('scalp electric potential $\phi_\mathbf{p}(\mathbf{r})$')
ax5 = fig.add_subplot(gs[7:, 2], sharey=ax4) # MEG
# ax5.set_title('scalp magnetic field')
#morphology - line sources for panels A and B
zips = []
xz = cell.get_idx_polygons()
for x, z in xz:
zips.append(zip(x, z))
for ax in [ax0]:
polycol = PolyCollection(zips,
linewidths=(0.5),
def main():
f = open("game_output.txt", "r")
l = json.load(f)
min_time = 0
for val in l:
if min_time == 0:
min_time = val["time"]
if val["time"] < min_time:
min_time = val["time"]
max_time = 0
for val in l:
if max_time == 0:
max_time = val["time"]
if val["time"] > max_time:
max_time = val["time"]
print "%s %s" % (min_time, max_time)
fig = plt.figure(1)
fig.subplots_adjust(right=0.85)
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
# make right and top axis invisible
ax.axis["right"].set_visible(False)
ax.axis["top"].set_visible(False)
# make xzero axis (horizontal axis line through y=0) visible.
ax.axis["xzero"].set_visible(False)
#ax.axis["xzero"].label.set_text("Axis Zero")
ax.set_xlim(min_time, max_time)
ax.set_ylim(0, 4)
ax.set_xlabel("Time")
ax.set_ylabel("HRV")
# make new (right-side) yaxis, but wth some offset
# offset = (20, 0)
# new_axisline = ax.get_grid_helper().new_fixed_axis
# ax.axis["right2"] = new_axisline(loc="right",
# offset=offset,
# axes=ax)
# ax.axis["right2"].label.set_text("Label Y2")
#ax.plot([-2,3,2])
t_hrv = []
hrv = []
for val in l:
if "hrv" in val.keys():
t_hrv.append(val["time"])
hrv.append(val["hrv"])
#ax.plot(val["time"], val["hrv"], 'b,')
elif "key" in val.keys():
ax.plot(val["time"], 2.0, 'r,')
ax.plot(t_hrv, hrv, 'b-')
hrv_dict = []
for el in l:
try:
hrv_dict.append((el["time"], el["hrv"]))
except KeyError:
pass
peak_dict = []
current_peak = 0
hrv_window = deque()
hrv_limit = 20
hrv_total = []
stop_counter = 0
hrv_itr = hrv_dict.__iter__()
b = hrv_itr.next()
while 1:
a = [b[0], b[1], 0]
hrv_window.append(a)
hrv_total.append(a)
if len(hrv_window) > hrv_limit:
hrv_window.popleft()
max_hrv = 0
max_time = 0
for h in hrv_window:
if h[1] > max_hrv:
max_time = h[0]
max_hrv = h[1]
for h in hrv_window:
if h[0] == max_time:
h[2] = h[2] + 1
break
try:
c = hrv_itr.next()
b = c
except StopIteration:
stop_counter = stop_counter + 1
if stop_counter == hrv_limit:
break
pulse = 0
for (time, hrv, score) in hrv_total:
if score > 17:
pulse = pulse + 1
ax.plot(time, hrv, 'g,')
print "Pulse: %s" % (pulse)
plt.draw()
plt.show()
def visualize_test_between_class(self, test, human, non_human):
fig = plt.figure("Trajectories for Test, Human, and Non-Human")
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
line_style = ['r.-', 'gx-', 'bo-']
# plotting test data
x = [i.pose.position.x for i in test]
y = [i.pose.position.y for i in test]
ax.plot(x, y, line_style[0], label="Test")
# plotting human data
x = [i.pose.position.x for i in human]
y = [i.pose.position.y for i in human]
ax.plot(x, y, line_style[1], label="Human")
# plotting non-human data
x = [i.pose.position.x for i in non_human]
y = [i.pose.position.y for i in non_human]
ax.plot(x, y, line_style[2], label="Non-human")
ax.margins(0.05)
ax.legend(loc="lower right", fontsize=10)
plt.title("Chunks of Trajectories")
plt.xlabel("Axis")
plt.ylabel("Ordinate")
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
pylab.grid()
plt.show()
# ########################
Sigma=np.array([[S11,S12,S13],[S12,S22, S23 ],[S13,S23, S33 ]],float)
print("Sigma=", Sigma)
VP=np.linalg.eigvals(Sigma)
Sig_max= np.max((VP)) + 5
Sig_min= np.min((VP)) - 5
# ########################
# Set up the figure, the axis, and the plot element we want to animate
# ########################
fig = plt.figure(1)
# Espace x,y
# Espace Snn,Snt
ax2 = SubplotZero(fig, 111)
fig.add_subplot(ax2)
#
for direction in ["xzero", "yzero"]:
ax2.axis[direction].set_axisline_style("-|>")
ax2.axis[direction].set_visible(True)
#
for direction in ["left", "right", "bottom", "top"]:
ax2.axis[direction].set_visible(False)
ax2.set_aspect('equal')
ax2.set_xlim(Sig_min, Sig_max)
ax2.set_ylim(-(Sig_max-Sig_min)/2, (Sig_max-Sig_min)/2)
ax2.text(0., 1.05, '$\sigma_{nt}$',size=20, transform=BlendedGenericTransform(ax2.transData, ax2.transAxes))
ax2.text(1.05, -0.15, '$\sigma_{nn}$',size=20, transform=BlendedGenericTransform(ax2.transAxes, ax2.transData))
from classification import linear_regression
from utils import load_data
verbose = True
max_iter = 500
X, Y = load_data('classificationA.train')
beta, u = linear_regression(X, Y)
# Let's plot the result
fig = plt.figure(1)
colors = ['#4EACC5', '#FF9C34', '#4E9A06']
my_members = Y == 0
my_members.shape = (my_members.shape[0])
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
ax.plot(X[my_members, 0], X[my_members, 1],
'w', markerfacecolor=colors[0], marker = '.')
my_members = Y == 1
my_members.shape = (my_members.shape[0])
#!/usr/bin/python
print "content-type: text/html\n"
import cgi,cgitb
cgitb.enable()
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
import numpy as np
if 1:
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
x = np.linspace(-0.5, 1., 100)
ax.plot(x, np.sin(x*np.pi))
plt.show()
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
if 1:
fig = plt.figure(1)
fig.subplots_adjust(right=0.85)
ax = SubplotZero(fig, 1, 1, 1)
fig.add_subplot(ax)
ax.axis["right"].set_visible(False)
ax.axis["top"].set_visible(False)
ax.axis["xzero"].set_visible(True)
ax.axis["xzero"].label.set_text("Axis Zero")
ax.set_ylim(-2, 4)
ax.set_xlabel("Label X")
ax.set_ylabel("Label Y")
offset = (20, 0)
new_axisline = ax.get_grid_helper().new_fixed_axis
ax.axis["right2"] = new_axisline(loc="right",
offset=offset,
axes=ax)
ax.axis["right2"].label.set_text("Label Y2")
ax.plot([-2,3,2])
plt.draw()
plt.show()
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.axes_grid.axislines import SubplotZero
# 図の背景の諸体裁を設定
# 作図スペースを用意(?)。個々のコードの意味がわかりません。
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
# 軸の設定
ax.axhline(linewidth=1.2, color="black")
ax.axvline(linewidth=1.2, color="black")
# 軸に矢印
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
# 四方のaxis(?)、spine(?)を消す
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
# 軸に名前を付ける。位置は適宜設定。
plt.figtext(0.93, 0.37, 'x')
plt.figtext(0.505, 0.95, 'y')
def f(x, a):
return a*x-x**2 # 包絡線の式を入れる
p = -3 # xの最小値
q = 3 # xの最大値
n = 12 # 引く包絡線の数
a_min = -10 # 表示させるaの最小値
a_max = 10 # 表示させるaの最大値
y_min = -6 # 表示させるbの最小値(最大値はa軸とb軸の縮尺が1:1になるよう自動で決まる)
# アスペクト比を定めただけだと異常に縦長なグラフが出てくるのでylimを定めた
y_max = y_min+a_max-a_min # これは変数ではない
plt.figtext(0.85, 0.35, '$a$') # 直接位置を指定しているので、グラフの位置を変えるときにこれも変える
plt.figtext(0.5, 0.95, '$b$')
# ここより上に変数が入る
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
ax.axhline(linewidth=1.0, color="black")
ax.axvline(linewidth=1.0, color="black")
ax.set_xticks([]) # 空のlistを指定することでticksが入らない
ax.set_yticks([])
ax.set(aspect=1)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
plt.ylim(ymin=y_min) # この位置より前に置くとx方向が狭くなってしまった
plt.ylim(ymax=y_max)
a = linspace(a_min, a_max, (a_max-a_min) * 10) # 点の数はaの動く範囲の長さ×10,これで曲線にも対応する
# linspaceの点の数に小数が来ることがあり得るのですが、その場合は勝手に小数点以下を切り捨てた数の点をとってくれるようです
for i in range(n):
r = p+(q-p)*i/(n-1) # n個の接線を引き2個は両端にあるので区間はn-1等分される
"""
Copyright (c) 2012 Michael Markieta
See the file license.txt for copying permission.
"""
from polar_grid import polar_grid
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid.axislines import SubplotZero
# Setup plotting for our polar grid
fig = plt.figure(1, figsize=(7,7))
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
# add axis lines for coordinate geometry (4 quadrants)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>", size=.75)
ax.axis[direction].set_visible(True)
# remove axis lines/labels for rectangular geometry (-x and -y don't exist)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
X = [] # hold x-coordinates from radial dividers
Y = [] # hold y-coordinates from radial dividers
# Generate geometry for a polar grid of 4-unit radius, centroid at (-2,1), with 8 divisions and precision of 4000 points
geom = polar_grid(rho=4, centroid=(-2,1), theta=8, tau=4000)
# Add coordinates from each radial divider to the X and Y lists
for num in range(0, len(geom)):
for (x,y) in geom[num][1]:
cur_x0 = cur_x0 + (cur_a1 - cur_x0)/(i + 2)
cur_x1 = cur_x1 + (cur_a0 - cur_x1)/(i + 2)
return x0s, x1s
def ficthist(t):
x0_last = []
for i in range(t):
x0s, x1s = fict(t)
x0_last.append(x0s[-1])
return x0_last
x0s, x1s = fict(t)
fig, ax = plt.subplots()
ax.plot(x0s, 'r-')
ax.plot(x1s, 'b-')
#plt.savefig('fictitious.png')
#plt.savefig('fictitious.pdf')
plt.show()
fig = plt.figure()
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
ax.hist(ficthist(t))
#plt.savefig('fictitious_hist.png')
#plt.savefig('fictitious_hist.pdf')
plt.show()
def main(path, name):
from numpy import linspace, loadtxt
d = SimulatedData(path)
psth = d.spike_time.psth()
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
f1 = plt.figure(figsize=[6,8])
ax = SubplotZero(f1, 411)
f1.add_subplot(ax)
psth.plot_raster(ax)
ax = SubplotZero(f1, 412)
f1.add_subplot(ax)
psth.plot_rate(ax, smoothed=True)
ax = SubplotZero(f1, 413)
f1.add_subplot(ax)
dat = loadtxt(d.path['ML response'])
t = linspace(0, 5000, dat.size)
ax.plot(t, dat, 'k')
for direction in ["left", "right", "top", "bottom"]:
ax.axis[direction].set_visible(False)
logging.info(str(dir(ax.axis["bottom"])))
# ax.axis["bottom"].major_ticklabels=[]
ax.set_title("ML")
ax = SubplotZero(f1, 414)
f1.add_subplot(ax)
dat = loadtxt(d.path['HHLS response'])
t = linspace(0, 5000, dat.size)
ax.plot(t, dat, 'k')
for direction in ["left", "right", "top"]:
ax.axis[direction].set_visible(False)
ax.axis["bottom"].set_label("Time (ms)")
ax.set_title("HHLS")
f1.subplots_adjust(hspace=0.47, top=0.95, bottom=0.05)
f2 = plt.figure(figsize=[4,4])
ax = SubplotZero(f2, 111)
f2.add_subplot(ax)
mf = psth.hist_mean_rate(ax, bins=linspace(0,8,20))
ax.set_title({"highvar": "High variance", "lowvar": "Low variance"}[name])
print "Mean firing rate =", mf.mean(), "Hz", "(", mf.std(),")"
plt.show()
#!/bin/env python
from mpl_toolkits.axes_grid.axislines import SubplotZero
import matplotlib.pyplot as plt
import numpy as np
if 1:
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
for direction in ["xzero", "yzero"]:
ax.axis[direction].set_axisline_style("-|>")
ax.axis[direction].set_visible(True)
for direction in ["left", "right", "bottom", "top"]:
ax.axis[direction].set_visible(False)
x = np.linspace(-0.5, 1., 100)
ax.plot(x, np.sin(x * np.pi))
plt.show()
plt.savefig("foo.png")
plt.savefig("foo.eps")
plt.savefig("foo.pdf")
acceleration = pol2cart(aforce,adeg)
orig = [0,0]
h = orig + heading # normalized heading
x = orig + orientation # normalized orientation
g = orig + acceleration
print h,x,g
soa = np.array([h,x,g]) # vectors
print soa
X,Y,U,V = zip(*soa) # convert to turples of U and V components
fig = plt.figure(1)
ax = SubplotZero(fig, 111)
fig.add_subplot(ax)
colors = ('r','g','b')
qv = ax.quiver(X,Y,U,V,color=colors,angles='xy',scale_units='xy',scale=1)
labels = ('heading: {} deg'.format(hdeg), 'Orientation, drift: {} deg'.format(drift), '{} g at {} deg'.format(aforce,adeg))
pos = ('N','E','S')
for x,y,l,c,p in zip(U,V,labels,colors,pos):
plt.quiverkey(qv,x,y,0,l,color=c,coordinates='data',labelpos=p)
ax.set_xlim([-2,2])
ax.set_ylim([-2,2])
# show cartisian axis
# for direction in ["xzero", "yzero"]:
# ax.axis[direction].set_visible(True)
