def plot_motion_field_streamplot(UV, geodata=None):
"""Function to plot a precipitation field witha a colorbar.
Parameters
----------
UV : array-like
Array of shape (2, m,n) containing the input motion field.
geodata : dictionary
step : int
Returns:
----------
ax : fig axes
Figure axes. Needed if one wants to add e.g. text inside the plot.
"""
# prepare X Y coordinates
if geodata is not None:
x = np.arange(geodata['x1'] / 1000, geodata['x2'] / 1000)
y = np.arange(geodata['y1'] / 1000, geodata['y2'] / 1000)
else:
x = np.arange(UV.shape[2])
y = np.arange(UV.shape[1])
plt.streamplot(x, y, UV[0, :, :], -UV[1, :, :], density=2, color='black')
axes = plt.gca()
if geodata is None:
axes.xaxis.set_ticklabels([])
axes.yaxis.set_ticklabels([])
return axes
def plot_field(self,x,y,u=None,v=None,F=None,contour=False,outdir=None,plot='quiver',figname='_field',format='eps'):
outdir = self.set_dir(outdir)
p = 64
if F is None: F=self.calc_F(u,v)
plt.close('all')
plt.figure()
#fig, axes = plt.subplots(nrows=1)
if contour:
plt.hold(True)
plt.contourf(x,y,F)
if plot=='quiver':
plt.quiver(x[::p],y[::p],u[::p],v[::p],scale=0.1)
if plot=='pcolor':
plt.pcolormesh(x[::4],y[::4],F[::4],cmap=plt.cm.Pastel1)
plt.colorbar()
if plot=='stream':
speed = F[::16]
plt.streamplot(x[::16], y[::16], u[::16], v[::16], density=(1,1),color='k')
plt.xlabel('$x$ (a.u.)')
plt.ylabel('$y$ (a.u.)')
plt.savefig(os.path.join(outdir,figname+'.'+format),format=format,dpi=320,bbox_inches='tight')
plt.close()
def streamplot(UV, geodata=None, **kwargs):
"""Function to plot a motion field as streamlines.
Parameters
----------
UV : array-like
Array of shape (2, m,n) containing the input motion field.
geodata : dictionary
Optional dictionary containing geographical information about the field.
If geodata is not None, it must contain the following key-value pairs:
x1 x-coordinate of the lower-left corner of the data raster (meters)
y1 y-coordinate of the lower-left corner of the data raster (meters)
x2 x-coordinate of the upper-right corner of the data raster (meters)
y2 y-coordinate of the upper-right corner of the data raster (meters)
yorigin a string specifying the location of the first element in
the data raster w.r.t. y-axis:
'upper' = upper border
'lower' = lower border
Optional kwargs
---------------
density : float
Controls the closeness of streamlines.
Default : 1.5
color : string
Optional streamline color. This is a synonym for the PolyCollection
facecolor kwarg in matplotlib.collections.
Default : black
Returns:
----------
ax : fig axes
Figure axes. Needed if one wants to add e.g. text inside the plot.
"""
# defaults
density = kwargs.get("density", 1.5)
color = kwargs.get("color", "black")
# prepare x y coordinates
if geodata is not None:
x = np.linspace(geodata['x1']/geodata["xpixelsize"], geodata['x2']/geodata["xpixelsize"], UV.shape[2])
y = np.linspace(geodata['y1']/geodata["ypixelsize"], geodata['y2']/geodata["ypixelsize"], UV.shape[1])
else:
x = np.arange(UV.shape[2])
y = np.arange(UV.shape[1],0,-1)
plt.streamplot(x, np.flipud(y), UV[0,:,:], -UV[1,:,:], density=density,
color=color)
axes = plt.gca()
if geodata is None:
axes.xaxis.set_ticklabels([])
axes.yaxis.set_ticklabels([])
return axes
def plot_streamline(x,y,u,v,outdir='./',outname='field_stream',format='eps'):
if not os.path.exists(outdir): os.makedirs(outdir)
speed = np.sqrt(u**2+v**2)
plt.close('all')
plt.figure()
plt.streamplot(x, y, u, v, color=speed,linewidth=5*speed/speed.max(),cmap=plt.cm.jet)
plt.savefig(os.path.join(outdir,outname+'.'+format),format=format,dpi=320,bbox_inches='tight')
plt.close()
return
def potential(x_axis,
y_axis,
cbar,
x_label,
y_label,
cbar_label,
int_pol,
colorMap,
xmin=None,
xmax=None,
ymin=None,
ymax=None,
plot=None):
"""A general plotter allowing for the plotting of a heatmap(primarily used
here for potential function) which takes in relevant data about the
graph. It also allows for the option of overlaying either a quiver or a
streamline plot, or not!
Parameters:
x_axis, y_axis : The corresponding x and y axis data lists of a plot
cbar: The heatmap list data which usually corresponds to x and y axis
x_label, y_label, : The x, y and z label of the graph dtype = string
cbar_label : The colourbar label dtype = string
int_pol: The colour interpolation of the heatmap dtype = integer
colorMap: The style and colour of heatmap dtype = string
xmin, xmax: The minimum and maximum value of the x-axis
ymin, ymax: The minimum and maximum value of the y-axis
plot: "quiver", "stream" allowing for the overlay of quiver or streamline
plot
Returns:
Image : AxesImage
"""
plt.contourf(x_axis, y_axis, cbar, int_pol, cmap=colorMap)
cbar_tag = plt.colorbar()
Z = cbar
plt.xlabel(x_label)
plt.ylabel(y_label)
cbar_tag.set_label(cbar_label, rotation=270)
cbar_tag.set_clim(-1000.0, 1000.0)
E = np.gradient(Z)
E = E / np.sqrt(E[0]**2 + E[1]**2)
if plot is not None:
if plot == "quiver":
print("\nQuiver plot:")
plt.quiver(x_axis, y_axis, E[1], E[0])
if plot == "stream":
print("\nStreamline Plot:")
plt.streamplot(x_axis, y_axis, -E[1], -E[0], color='black')
if xmin is not None and xmax is not None:
plt.xlim(xmin, xmax)
if ymin is not None and ymax is not None:
plt.ylim(ymin, ymax)
plt.show()
def plot_field(self,
x,
y,
u=None,
v=None,
F=None,
contour=False,
outdir=None,
plot='quiver',
figname='_field',
format='eps'):
outdir = self.set_dir(outdir)
p = 64
if F is None: F = self.calc_F(u, v)
plt.close('all')
plt.figure()
#fig, axes = plt.subplots(nrows=1)
if contour:
plt.hold(True)
plt.contourf(x, y, F)
if plot == 'quiver':
plt.quiver(x[::p], y[::p], u[::p], v[::p], scale=0.1)
if plot == 'pcolor':
plt.pcolormesh(x[::4], y[::4], F[::4], cmap=plt.cm.Pastel1)
plt.colorbar()
if plot == 'stream':
speed = F[::16]
plt.streamplot(x[::16],
y[::16],
u[::16],
v[::16],
density=(1, 1),
color='k')
plt.xlabel('$x$ (a.u.)')
plt.ylabel('$y$ (a.u.)')
plt.savefig(os.path.join(outdir, figname + '.' + format),
format=format,
dpi=320,
bbox_inches='tight')
plt.close()
def plot_streamline(x,
y,
u,
v,
outdir='./',
outname='field_stream',
format='eps'):
if not os.path.exists(outdir): os.makedirs(outdir)
speed = np.sqrt(u**2 + v**2)
plt.close('all')
plt.figure()
plt.streamplot(x,
y,
u,
v,
color=speed,
linewidth=5 * speed / speed.max(),
cmap=plt.cm.jet)
plt.savefig(os.path.join(outdir, outname + '.' + format),
format=format,
dpi=320,
bbox_inches='tight')
plt.close()
return
import matplotlib.pylab as plt
import numpy as np
from math import sqrt, cos, sin, log, exp, pi
w = 3
Y, X = np.mgrid[-w:w:100j, -w:w:100j]
U = X**2 + Y**2
V = X**2 - Y**2
speed = np.sqrt(U**2 + V**2)
lw = 5 * speed / speed.max()
p = plt.figure(figsize=(14, 14), facecolor='black', dpi=400)
p = plt.axis('off')
plt.streamplot(X,
Y,
U,
V,
density=[2, 2],
arrowsize=1,
cmap='summer',
color=U,
linewidth=lw**0.85,
arrowstyle='fancy')
p = plt.savefig(f'C:/Users/Alejandro/Pictures/RandomPlots/03052020.PNG',
facecolor='black')
# Plot weighting field directions
E_x, E_y = get_weighting_field(xx,
yy,
D=thickness,
S=width,
is_planar=True)
# Indexing is different here (mixing array indexing and cartesian coordinates)
# Similar issue: http://stackoverflow.com/questions/22568256/2d-quiver-plot-matplotlib-and-matlab-output-doesnt-match
E_y_2, E_x_2 = np.gradient(-phi_w, np.gradient(y), np.gradient(x))
plt.streamplot(x,
y,
E_x_2,
E_y_2,
density=1.0,
color='black',
arrowstyle='->')
plt.streamplot(x, y, E_x, E_y, density=1.0, color='gray', arrowstyle='->')
plt.title(
'Weighting potential and weighting field direction (planar sensor)')
plt.xlabel('Position [um]')
plt.ylabel('Depth [um]')
# print np.where(np.logical_or(E_x - E_x_2 > 0.1, E_y - E_y_2 > 0.1))
# print E_x[np.where(E_x - E_x_2 == (E_x - E_x_2).max())], E_x_2[np.where(E_x - E_x_2 == (E_x - E_x_2).max())], x[0], y[75]
# plt.savefig('WeightingField_planar.pdf', layout='tight')
xs, ys = [], []
import numpy as np
import matplotlib.pylab as plt
Sol=np.genfromtxt('campo.txt')
potencial=Sol[:513,:]
Ex=Sol[513:2*513,:]
Ey=Sol[2*513:,:]
plt.imshow(potencial,cmap=plt.cm.inferno,extent=(-2.5, 2.5, -2.5,2.5))
x=np.linspace(-2.5,2.5,513)
y=np.linspace(-2.5,2.5,513)
X,Y = np.meshgrid(x, y)
color = 2 * np.log(np.hypot(Ex, Ey))
plt.streamplot(X,Y,Ex,Ey, color=color, linewidth=0.5, cmap=plt.cm.inferno,
density=2, arrowstyle='->', arrowsize=1)
plt.savefig('placas.pdf')
if keep == "n":
break
"""
As posições do gráfico são referentes as posiçoes das cargas deixadas pelo usuário
O mínimo no eixo x é o valor mínimo que uma carga se situa no eixo x menos 1, assim como no eixo y
O mesmo se aplica para o valor máximo para ambos os eixos
"""
x0, x1 = min([c.position[0]
for c in cargas]) - 1, max([c.position[0] for c in cargas]) + 1
y0, y1 = min([c.position[1]
for c in cargas]) - 1, max([c.position[1] for c in cargas]) + 1
# Funções referentes à criação de matrizes para as pposições de linhas de campo
x = np.linspace(x0, x1, 64)
y = np.linspace(y0, y1, 64)
x, y = np.meshgrid(x, y)
# Cálculo das cargas e plotagem no gráfico
Ex, Ey = E_total(x, y, cargas).get_campos_eixos()
color = 2 * np.log(np.hypot(Ex, Ey))
plt.streamplot(x, y, Ex, Ey, color=color, linewidth=1, cmap=plt.cm.inferno)
# Posicionamento das cargas pontuais no Gráfico
for C in cargas:
if C.load > 0:
plt.plot(C.position[0], C.position[1], 'bo', ms=8 * np.sqrt(C.load))
if C.load < 0:
plt.plot(C.position[0], C.position[1], 'ro', ms=8 * np.sqrt(-C.load))
plt.show()
ax = pl.subplot(111)
print ax.axis()
grid = pl.grid()
poly = pl.Polygon([(0, 0), (xReg[1], 0), (xReg[1], -xReg[1] / 9 * 12.)], color='k', alpha=0.2)
ax.add_patch(poly)
poly = pl.Polygon([(0, 0), (xReg[0], -xReg[0] * 4), (xReg[0], yReg[0]), (xReg[1], -xReg[1] * 2.)], color='k', alpha=0.4)
ax.add_patch(poly)
pl.plot(XPlus, XPlus / 9 * (-12.), 'k--')
pl.plot(XPlus, XPlus * 0, 'k--')
pl.plot(XPlus, -XPlus * 2, 'k--')
pl.plot(XMinus, -XMinus * 4, 'k--')
pl.axis([xReg[0], xReg[1], yReg[0], yReg[1]])
#pl.streamplot(X, Y, U, V, color=speed)
pl.streamplot(X, Y, U, V, color='k')
#pl.colorbar()
pl.plot([0], [0], 'wo', ms=8)
pl.plot([3. / 7, 9. / 11], [0, -12. / 11], 'ko', ms=8)
pl.plot([12. / 17], [-12. / 17], 'kD', ms=8)
annotationSize = 15
ax.annotate('O', xy=(0, 0.), size=annotationSize, xycoords='data',
xytext=( 0.03, 0.1), textcoords='data',
bbox=dict(boxstyle="round", fc='1.'))
ax.annotate('A', xy=(3. / 7, 0.), size=annotationSize, xycoords='data',
xytext=(3. / 7 + 0.03, 0.1), textcoords='data',
bbox=dict(boxstyle="round", fc='1.'))
ax.annotate('B', xy=(12. / 17, -12. / 17), size=annotationSize, xycoords='data',
xytext=(12. / 17 + 0.03, -12. / 17 + 0.1), textcoords='data',
bbox=dict(boxstyle="round", fc='1.'))
ax.annotate('C', xy=(9. / 11, -12. / 11), size=annotationSize, xycoords='data',
def plot_memb_current_for_cell(time_pt,
params,
plot_morpho=False,
plot_field=True,
plot_synapses=False,
plot_current=False,
ax=None):
# this is used for frames of the movie
v_ext, xx, yy, seg_coords, x_range, y_range, dt = params
#v_ext, xx, yy, seg_coords, x_range, y_range, inh_syn_coords, exc_syn_coords, dt = params
max_field = np.max(v_ext)
if max_field >= 1000:
# convert to microvolts
v_ext = v_ext / 10e2 # change to microvolts
scale_type = 'micro'
max_field /= 10e2
else:
scale_type = 'nano'
#v_ext = v_ext / 10e2 # change nano to micro volts
import matplotlib.colors as colors
if ax == None:
ax = plt.subplot(1, 1, 1)
# draw field
mycmap, colormap_range_ceil, aspect, one_forth_colormap, colormap_range = helper_provide_imshow_details(
v_ext, x_range, y_range)
if plot_field:
pcm = plt.imshow(
v_ext[time_pt, :, :],
interpolation="nearest",
#norm=colors.SymLogNorm(linthresh=0.01 * np.max(v_ext),
# linscale=1.0,
# vmin=colormap_range_ceil[0], vmax=colormap_range_ceil[1]),
origin='lower',
aspect=0.8,
extent=(x_range[0], x_range[1], y_range[0], y_range[1]),
cmap=mycmap)
plt.clim(colormap_range[0], colormap_range[1])
if plot_morpho:
# draw morpho
import pdb
pdb.set_trace()
col = graph.plot_neuron(seg_coords, colors='k', autolim=True)
soma_idcs, = np.where(seg_coords['name'] == 'soma')
draw_soma(ax,
x0=seg_coords[soma_idcs[0]]['x0'],
x1=seg_coords[soma_idcs[-1]]['x1'],
y0=seg_coords[soma_idcs[0]]['y0'],
y1=seg_coords[soma_idcs[-1]]['y1'],
color='k')
plt.xlim(x_range)
plt.ylim(y_range)
x_tic_label, xtics, y_tic_label, ytics = helper_define_tick_space(
x_range, y_range)
ax.set_yticks(ytics)
ax.set_yticklabels(y_tic_label)
ax.set_xticks(xtics)
ax.set_xticklabels(x_tic_label)
if plot_field:
cbar = plt.colorbar(pcm, extend='both', drawedges=False) # ax=ax[0],
cbar.set_ticks([
colormap_range[0], -one_forth_colormap, 0, one_forth_colormap,
colormap_range[1]
])
cbar.set_ticklabels([
str(colormap_range[0]),
str(-one_forth_colormap), '0',
str(one_forth_colormap), colormap_range[1]
])
if scale_type == 'micro':
cbar.set_label(r"voltage ($\mu$V)", fontsize=18)
elif scale_type == 'nano':
cbar.set_label(r"voltage (nV)", fontsize=18)
#cbar.set_label(r"voltage ($\mu$V)", fontsize=18)
#cbar.set_label(r"voltage (nV)", fontsize=18)
cbar.ax.tick_params(labelsize=16)
if plot_current:
# draw streamplots
U = -np.diff(v_ext[time_pt, :, :], axis=0)[:, :-1]
V = -np.diff(v_ext[time_pt, :, :], axis=1)[:-1, :]
plt.streamplot(xx[0, :-1], yy[:-1, 0], V, U, density=1.0, color='g')
plt.title('time: ' + str(("%0.2f" % (time_pt * dt))) + 'ms')
ax.set_xlabel(r"space ($\mu$m)")
ax.set_ylabel(r"space ($\mu$m)")
clean_plot(ax)
plt.tight_layout()
return mycmap, colormap_range