def __init__(self, x, y, cells,**kwargs):
self.__dict__.update(kwargs)
Triangulation.__init__(self,x,y,cells)
self.Nc = cells.shape[0]
def buildTriangulation( self, x, y ):
trig=None
if qgis_qhull_fails:
trig=self._buildtrig_workaround(x,y)
else:
trig=Triangulation(x,y)
analyzer=TriAnalyzer(trig)
mask=analyzer.get_flat_tri_mask()
trig.set_mask(mask)
return trig
def PlotPoly(self):
for i in range(0,len(self.poly)):
if i < len(self.poly)-1:
X = np.vstack((self.poly[i],self.poly[i+1]))
else:
X = self.poly[i]
X = np.vstack((X[:,0],X[:,1],X[:,3])).T
hull = ConvexHull(X,qhull_options=self.qhull_options)
x,y,z=X.T
tri = Triangulation(x, y, triangles=hull.simplices)
triangle_vertices = np.array([np.array([[x[T[0]], y[T[0]], z[T[0]]],
[x[T[1]], y[T[1]], z[T[1]]],
[x[T[2]], y[T[2]], z[T[2]]]]) for T in tri.triangles])
self.tri = tri
tri = Poly3DCollection(triangle_vertices)
if i == len(self.poly)-1:
tri.set_color(self.COLOR_REACHABLE_SET_LAST)
tri.set_edgecolor(self.rs_last_edge_color)
#self.image.scatter(x,y,z, 'ok', color=np.array((0,0,1.0,0.1)),s=30)
else:
color_cur = copy.copy(self.COLOR_REACHABLE_SET_LAST)
color_cur[3] = color_cur[3]/2.0
tri.set_color(color_cur)
tri.set_edgecolor('None')
self.image.add_collection3d(tri)
def getEdgesSLF(IKLE,MESHX,MESHY,showbar=True):
try:
from matplotlib.tri import Triangulation
edges = Triangulation(MESHX,MESHY,IKLE).get_cpp_triangulation().get_edges()
except:
#print '... you are in bad luck !'
#print ' ~> without matplotlib based on python 2.7, this operation takes ages'
edges = []
ibar = 0
if showbar: pbar = ProgressBar(maxval=len(IKLE)).start()
for e in IKLE:
ibar += 1
if showbar: pbar.update(ibar)
if [e[0],e[1]] not in edges: edges.append([e[1],e[0]])
if [e[1],e[2]] not in edges: edges.append([e[2],e[1]])
if [e[2],e[0]] not in edges: edges.append([e[0],e[2]])
if showbar: pbar.finish()
return edges
def reload(self, imageName):
#Let's create a canvas
self.w.pack()
self.w.delete("all")
#Let's create an image
image = Image.open(imageName)
pixels = image.load()
width, height = image.size
#Just a testing data structure. Don't use this.
all_pixels = []
#Use this one when doing calculations.
points = []
xarray = []
yarray = []
color = ["red", "orange", "yellow", "green", "blue", "violet"]
#loop(self, points, pixels, all_pixels, width, height)
for x in range(width):
for y in range(height):
cpixel = pixels[x, y]
foo = random.randint(1, 7)
if (round(sum(cpixel)) / float(len(cpixel)) > 127) & (x%foo == 0) & (y%foo == 0):
all_pixels.append(255)
points.append(Point(x*2, y*2))
xarray.append(x*2)
yarray.append(1000 - y*2)
#self.w.create_oval(x*2, y*2, x*2+1, y*2+1, fill="black")
else:
all_pixels.append(0)
triangulation = Triangulation(xarray, yarray)
triangles = triangulation.get_masked_triangles()
polygons = []
for triangle in triangles:
self.w.create_polygon([xarray[triangle[0]], 1000 - yarray[triangle[0]]], [xarray[triangle[1]], 1000 - yarray[triangle[1]]], [xarray[triangle[2]], 1000 - yarray[triangle[2]]], fill=random.choice(color))
def get_triangulation(lon, lat):
return Triangulation(lon, lat)
rotf = asm(unit_load, ib)
psi = solve(*condense(stokes, rotf, D=ib.find_dofs()))
psi0, = ib.interpolator(psi)(np.zeros((2, 1)))
if __name__ == "__main__":
from os.path import splitext
from sys import argv
from skfem.visuals.matplotlib import draw
from matplotlib.tri import Triangulation
print('psi0 = {} (cf. exact = 1/64 = {})'.format(psi0, 1/64))
M, Psi = ib.refinterp(psi, 3)
ax = draw(mesh)
ax.tricontour(Triangulation(*M.p, M.t.T), Psi)
name = splitext(argv[0])[0]
ax.get_figure().savefig(f'{name}_stream-lines.png')
refbasis = InteriorBasis(M, ElementTriP1())
velocity = np.vstack([derivative(Psi, refbasis, refbasis, 1),
-derivative(Psi, refbasis, refbasis, 0)])
ax = draw(mesh)
sparsity_factor = 2**3 # subsample the arrows
vector_factor = 2**3 # lengthen the arrows
x = M.p[:, ::sparsity_factor]
u = vector_factor * velocity[:, ::sparsity_factor]
ax.quiver(*x, *u, x[0])
ax.get_figure().savefig(f'{name}_velocity-vectors.png')
import argiope as ag
import numpy as np
import pandas as pd
from matplotlib.tri import Triangulation
mesh = ag.mesh.read_msh("demo.msh")
conn = mesh.split("simplices").unstack()
coords = mesh.nodes.coords.copy()
node_map = pd.Series(data=np.arange(len(coords)), index=coords.index)
conn = node_map.loc[conn.values.flatten()].values.reshape(*conn.shape)
triangulation = Triangulation(coords.x.values, coords.y.values, conn)
"""
nodes, elements = mesh.nodes, mesh.elements
#NODES
nodes_map = np.arange(nodes.index.max()+1)
nodes_map[nodes.index] = np.arange(len(nodes.index))
nodes_map[0] = -1
coords = nodes.coords.as_matrix()
#ELEMENTS
connectivities = elements.conn.as_matrix()
connectivities[np.isnan(connectivities)] = 0
connectivities = connectivities.astype(np.int32)
connectivities = nodes_map[connectivities]
labels = np.array(elements.index)
etype = np.array(elements.type.argiope).flatten()
print(etype)
#TRIANGLES
x, y, tri = [], [], []
for i in range(len(etype)):
triangles = connectivities[i][argiope.mesh.ELEMENTS[etype[i]]["simplices"]]
for t in triangles:
def scatter_xyz(points, smooth=0, div=100, ax=None, **options):
"""
Draws a 3D graph (X, Y, Z).
The function requires :epkg:`matploblib`
and :epkg:`scipy`.
@param points (x,y, z=f(x,y) )
@param div number of divisions for axis
@param smooth applies n times a smoothing I * M (convolutional)
@param ax existing graph to plot on (can be None)
@param options others options: xlabel, ylabel, zlabel, title, elev, angle, figsize (if ax is None)
- elev, angle: see `view_init <http://matplotlib.org/mpl_toolkits/mplot3d/api.html>`_)
@return fig, ax (fig is None if ax was sent to the function)
If *ax is None*, axes are created like::
fig = plt.figure(figsize=options.get('figsize', None))
ax = fig.gca(projection='3d')
.. plot::
:include-source:
import random
def generate_gauss(x, y, sigma, N=1000):
res = []
for i in range(N):
u = random.gauss(0, 1)
a = sigma * u + x
b = sigma * random.gauss(0, 1) + y + u
res.append((a, b))
return res
def f(a, b):
return (a ** 2 + b ** 2) ** 0.5
nuage1 = generate_gauss(0, 0, 3)
nuage2 = generate_gauss(3, 4, 2)
nuage = [(a, b, f(a, b)) for a, b in nuage1] + [(a, b, f(a, b)) for a, b in nuage2]
import matplotlib.pyplot as plt
from ensae_teaching_cs.helpers.matplotlib_helper_xyz import scatter_xyz
fig, ax = scatter_xyz(nuage, title="example with random observations")
plt.show()
The error ``ValueError: Unknown projection '3d'`` is raised when the line
``from mpl_toolkits.mplot3d import Axes3D`` is missing.
"""
x = [_[0] for _ in points]
y = [_[1] for _ in points]
z = [_[2] for _ in points]
if ax is None:
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
if Axes3D is None:
raise ImportError("Unable to import mpl_toolkits.mplot3d")
fig = plt.figure(figsize=options.get('figsize', None))
ax = fig.gca(projection='3d')
else:
fig = None
elev = options.get("elev", 50)
angle = options.get("angle", 45)
ax.view_init(elev, angle)
tri = Triangulation(x, y)
ax.plot_trisurf(x, y, z, triangles=tri.triangles, cmap='autumn')
if "xlabel" in options:
ax.set_xlabel(options["xlabel"])
if "ylabel" in options:
ax.set_ylabel(options["ylabel"])
if "zlabel" in options:
ax.set_ylabel(options["zlabel"])
if "title" in options:
ax.set_title(options["title"])
return fig, ax
def getMPLTri(MESHX,MESHY,IKLE): from matplotlib.tri import Triangulation mpltri = Triangulation(MESHX,MESHY,IKLE).get_cpp_triangulation() return mpltri.get_neighbors(),mpltri.get_edges()
plt.figure(figsize = [6.4, 3.8])
#Loop through each time step and plot results
for ind in range(0, len(timeindays)):
dt = datetime.datetime.combine(datetime.date(1990, 1, 1), datetime.time(0, 0)) + datetime.timedelta(days=timeindays[ind])
dstr = datetime.date.strftime(dt,'%Y%m%d%H:%M:%S')
dstr = dstr[0:8]+' '+dstr[8:17]
print('Plotting '+dstr)
par=np.double(wlv[ind,:])
par2=np.double(ucur[ind,:])
par3=np.double(vcur[ind,:])
flatness=0.10 # flatness is from 0-.5 .5 is equilateral triangle
tri=Triangulation(lon,lat)
mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
tri.set_mask(mask)
tli=LinearTriInterpolator(tri,par)
par_interp=tli(reflon,reflat)
tli2=LinearTriInterpolator(tri,par2)
par2_interp=tli2(reflon,reflat)
tli3=LinearTriInterpolator(tri,par3)
par3_interp=tli3(reflon,reflat)
#Set up a Mercator projection basemap
plt.clf()
#m=Basemap(projection='merc',llcrnrlon=reflon.min(),urcrnrlon=reflon.max(),\
# llcrnrlat=reflat.min(),urcrnrlat=reflat.max(),resolution='h')
#x,y=m(reflon,reflat)
def setMPLTri(self,set=False):
if set or self.neighbours == None or self.edges == None:
#from matplotlib.tri import Triangulation
mpltri = Triangulation(self.MESHX,self.MESHY,self.IKLE2).get_cpp_triangulation()
self.neighbours = mpltri.get_neighbors()
self.edges = mpltri.get_edges()
def element_finder(self):
from matplotlib.tri import Triangulation
return Triangulation(self.p[0, :], self.p[1, :],
self.t.T).get_trifinder()
def plot_backward_facing_step(res):
u = df.as_vector([res['u0'], res['u1']])
V = u[0].function_space()
mesh = V.mesh()
############################################################################
# Get some meta data
sim = Simulation()
sim.input.read_yaml(yaml_string=res['input'])
Re = sim.input.get_value('user_code/constants/Re', required_type='float')
time = res['time']
############################################################################
# Find the length X1 of primary recirculating bubble
x1_ypos = -0.99 * H2
xf, _, _, f = get_probe_values(u[0], [0, x1_ypos, 0], [L2, x1_ypos, 0], 200)
x1_c0 = get_zero_crossings(xf, f)
print(x1_c0)
############################################################################
# Find the inflow profile
x_inflow = -1.5 * H1
_, y_inflow, _, u0_inflow = get_probe_values(
u[0], [x_inflow, 0, 0], [x_inflow, H1, 0], 20
)
############################################################################
# Refine the mesh and get a triangluated stream function
for _ in range(2):
old = mesh, V
mesh = df.refine(mesh)
V = df.FunctionSpace(mesh, V.ufl_element())
df.parameters['allow_extrapolation'] = True
try:
u0 = df.interpolate(u[0], V)
u1 = df.interpolate(u[1], V)
u = df.as_vector([u0, u1])
except Exception:
mesh, V = old
u0, u1 = u[0], u[1]
print('Refining failed ------------------------------')
break
df.parameters['allow_extrapolation'] = False
sf = StreamFunction(u, degree=V.ufl_element().degree())
sf.compute()
levels = get_probe_values(
sf.psi, [1.5 * H2, -0.5 * H2, 0], [H2, H1 * 0.99, 0], N_levels
)[-1]
levels2 = []
for xi, _idx, _upcrossing in x1_c0:
# Add stream function values at upcrossing locations
if xi - 0.3 > 0:
levels2.append(get_probe_value(sf.psi, (xi - 0.3, x1_ypos, 0)))
if xi + 0.1 < L2:
levels2.append(get_probe_value(sf.psi, (xi + 0.1, x1_ypos, 0)))
if levels2:
levels = numpy.concatenate((levels, levels2))
levels.sort()
coords = mesh.coordinates()
triangles = []
for cell in df.cells(mesh):
cell_vertices = cell.entities(0)
triangles.append(cell_vertices)
triangulation = Triangulation(coords[:, 0], coords[:, 1], triangles)
Z = sf.psi.compute_vertex_values()
############################################################################
# Plot streamlines and velocity distributions
fig = pyplot.figure(figsize=(15, 2.5))
ax = fig.add_subplot(111)
ax.plot([-L1, -L1, 0, 0, L2, L2, -L1], [H1, 0, 0, -H2, -H2, H1, H1], 'k')
# ax.triplot(triangulation, color='#000000', alpha=0.5, lw=0.25)
ax.tricontour(
triangulation, Z, levels, linestyles='solid', colors='#0000AA', linewidths=0.5
)
ax.plot(x_inflow + u0_inflow, y_inflow, 'm')
ax.plot(x_inflow - 6 * (y_inflow - 1) * y_inflow, y_inflow, 'k.', ms=4)
# ax2 = fig.add_subplot(212)
# ax2.plot(xf, f)
# ax2.set_xlim(-L1, L2)
for xi, _idx, _upcrossing in x1_c0:
ax.plot(xi, x1_ypos, 'rx')
# ax.text(xi, x1_ypos+0.1, 'X1=%.3f' % x1, backgroundcolor='white')
ax.set_title(
'Re = %g, t = %g, xi = %s' % (Re, time, ', '.join('%.3f' % e[0] for e in x1_c0))
)
fig.tight_layout()
class MyFigure(FigureCanvas):
"""__图像显示类__
三个子图的初始化 & 三种重建图像的显示方式
"""
def __init__(self, width, height, dpi):
self.fig = plt.figure(figsize=(width, height), dpi=dpi)
super(MyFigure, self).__init__(self.fig)
self.gs = GridSpec(3, 2) #画布布局
# 用于三角剖分的顶点坐标
self.nodes = np.array([[0.0000e+00, 0.0000e+00],
[0.0000e+00, 8.3333e-02],
[8.3333e-02, 5.1027e-18],
[1.0205e-17, -8.3333e-02],
[-8.3333e-02, -1.5308e-17],
[0.0000e+00, 1.6667e-01],
[1.1785e-01, 1.1785e-01],
[1.6667e-01, 1.0205e-17],
[1.1785e-01, -1.1785e-01],
[2.0411e-17, -1.6667e-01],
[-1.1785e-01, -1.1785e-01],
[-1.6667e-01, -3.0616e-17],
[-1.1785e-01, 1.1785e-01],
[0.0000e+00, 2.5000e-01],
[1.2500e-01, 2.1651e-01],
[2.1651e-01, 1.2500e-01],
[2.5000e-01, 1.5308e-17],
[2.1651e-01, -1.2500e-01],
[1.2500e-01, -2.1651e-01],
[3.0616e-17, -2.5000e-01],
[-1.2500e-01, -2.1651e-01],
[-2.1651e-01, -1.2500e-01],
[-2.5000e-01, -4.5924e-17],
[-2.1651e-01, 1.2500e-01],
[-1.2500e-01, 2.1651e-01],
[0.0000e+00, 3.3333e-01],
[1.2756e-01, 3.0796e-01],
[2.3570e-01, 2.3570e-01],
[3.0796e-01, 1.2756e-01],
[3.3333e-01, 2.0411e-17],
[3.0796e-01, -1.2756e-01],
[2.3570e-01, -2.3570e-01],
[1.2756e-01, -3.0796e-01],
[4.0822e-17, -3.3333e-01],
[-1.2756e-01, -3.0796e-01],
[-2.3570e-01, -2.3570e-01],
[-3.0796e-01, -1.2756e-01],
[-3.3333e-01, -6.1232e-17],
[-3.0796e-01, 1.2756e-01],
[-2.3570e-01, 2.3570e-01],
[-1.2756e-01, 3.0796e-01],
[0.0000e+00, 4.1667e-01],
[1.2876e-01, 3.9627e-01],
[2.4491e-01, 3.3709e-01],
[3.3709e-01, 2.4491e-01],
[3.9627e-01, 1.2876e-01],
[4.1667e-01, 2.5513e-17],
[3.9627e-01, -1.2876e-01],
[3.3709e-01, -2.4491e-01],
[2.4491e-01, -3.3709e-01],
[1.2876e-01, -3.9627e-01],
[5.1027e-17, -4.1667e-01],
[-1.2876e-01, -3.9627e-01],
[-2.4491e-01, -3.3709e-01],
[-3.3709e-01, -2.4491e-01],
[-3.9627e-01, -1.2876e-01],
[-4.1667e-01, -7.6540e-17],
[-3.9627e-01, 1.2876e-01],
[-3.3709e-01, 2.4491e-01],
[-2.4491e-01, 3.3709e-01],
[-1.2876e-01, 3.9627e-01],
[0.0000e+00, 5.0000e-01],
[1.2941e-01, 4.8296e-01],
[2.5000e-01, 4.3301e-01],
[3.5355e-01, 3.5355e-01],
[4.3301e-01, 2.5000e-01],
[4.8296e-01, 1.2941e-01],
[5.0000e-01, 3.0616e-17],
[4.8296e-01, -1.2941e-01],
[4.3301e-01, -2.5000e-01],
[3.5355e-01, -3.5355e-01],
[2.5000e-01, -4.3301e-01],
[1.2941e-01, -4.8296e-01],
[6.1232e-17, -5.0000e-01],
[-1.2941e-01, -4.8296e-01],
[-2.5000e-01, -4.3301e-01],
[-3.5355e-01, -3.5355e-01],
[-4.3301e-01, -2.5000e-01],
[-4.8296e-01, -1.2941e-01],
[-5.0000e-01, -9.1849e-17],
[-4.8296e-01, 1.2941e-01],
[-4.3301e-01, 2.5000e-01],
[-3.5355e-01, 3.5355e-01],
[-2.5000e-01, 4.3301e-01],
[-1.2941e-01, 4.8296e-01],
[0.0000e+00, 5.8333e-01],
[1.2980e-01, 5.6871e-01],
[2.5310e-01, 5.2557e-01],
[3.6370e-01, 4.5607e-01],
[4.5607e-01, 3.6370e-01],
[5.2557e-01, 2.5310e-01],
[5.6871e-01, 1.2980e-01],
[5.8333e-01, 3.5719e-17],
[5.6871e-01, -1.2980e-01],
[5.2557e-01, -2.5310e-01],
[4.5607e-01, -3.6370e-01],
[3.6370e-01, -4.5607e-01],
[2.5310e-01, -5.2557e-01],
[1.2980e-01, -5.6871e-01],
[7.1438e-17, -5.8333e-01],
[-1.2980e-01, -5.6871e-01],
[-2.5310e-01, -5.2557e-01],
[-3.6370e-01, -4.5607e-01],
[-4.5607e-01, -3.6370e-01],
[-5.2557e-01, -2.5310e-01],
[-5.6871e-01, -1.2980e-01],
[-5.8333e-01, -1.0716e-16],
[-5.6871e-01, 1.2980e-01],
[-5.2557e-01, 2.5310e-01],
[-4.5607e-01, 3.6370e-01],
[-3.6370e-01, 4.5607e-01],
[-2.5310e-01, 5.2557e-01],
[-1.2980e-01, 5.6871e-01],
[0.0000e+00, 6.6667e-01],
[1.3006e-01, 6.5386e-01],
[2.5512e-01, 6.1592e-01],
[3.7038e-01, 5.5431e-01],
[4.7140e-01, 4.7140e-01],
[5.5431e-01, 3.7038e-01],
[6.1592e-01, 2.5512e-01],
[6.5386e-01, 1.3006e-01],
[6.6667e-01, 4.0822e-17],
[6.5386e-01, -1.3006e-01],
[6.1592e-01, -2.5512e-01],
[5.5431e-01, -3.7038e-01],
[4.7140e-01, -4.7140e-01],
[3.7038e-01, -5.5431e-01],
[2.5512e-01, -6.1592e-01],
[1.3006e-01, -6.5386e-01],
[8.1643e-17, -6.6667e-01],
[-1.3006e-01, -6.5386e-01],
[-2.5512e-01, -6.1592e-01],
[-3.7038e-01, -5.5431e-01],
[-4.7140e-01, -4.7140e-01],
[-5.5431e-01, -3.7038e-01],
[-6.1592e-01, -2.5512e-01],
[-6.5386e-01, -1.3006e-01],
[-6.6667e-01, -1.2246e-16],
[-6.5386e-01, 1.3006e-01],
[-6.1592e-01, 2.5512e-01],
[-5.5431e-01, 3.7038e-01],
[-4.7140e-01, 4.7140e-01],
[-3.7038e-01, 5.5431e-01],
[-2.5512e-01, 6.1592e-01],
[-1.3006e-01, 6.5386e-01],
[0.0000e+00, 7.5000e-01],
[1.3024e-01, 7.3861e-01],
[2.5652e-01, 7.0477e-01],
[3.7500e-01, 6.4952e-01],
[4.8209e-01, 5.7453e-01],
[5.7453e-01, 4.8209e-01],
[6.4952e-01, 3.7500e-01],
[7.0477e-01, 2.5652e-01],
[7.3861e-01, 1.3024e-01],
[7.5000e-01, 4.5924e-17],
[7.3861e-01, -1.3024e-01],
[7.0477e-01, -2.5652e-01],
[6.4952e-01, -3.7500e-01],
[5.7453e-01, -4.8209e-01],
[4.8209e-01, -5.7453e-01],
[3.7500e-01, -6.4952e-01],
[2.5652e-01, -7.0477e-01],
[1.3024e-01, -7.3861e-01],
[9.1849e-17, -7.5000e-01],
[-1.3024e-01, -7.3861e-01],
[-2.5652e-01, -7.0477e-01],
[-3.7500e-01, -6.4952e-01],
[-4.8209e-01, -5.7453e-01],
[-5.7453e-01, -4.8209e-01],
[-6.4952e-01, -3.7500e-01],
[-7.0477e-01, -2.5652e-01],
[-7.3861e-01, -1.3024e-01],
[-7.5000e-01, -1.3777e-16],
[-7.3861e-01, 1.3024e-01],
[-7.0477e-01, 2.5652e-01],
[-6.4952e-01, 3.7500e-01],
[-5.7453e-01, 4.8209e-01],
[-4.8209e-01, 5.7453e-01],
[-3.7500e-01, 6.4952e-01],
[-2.5652e-01, 7.0477e-01],
[-1.3024e-01, 7.3861e-01],
[0.0000e+00, 8.3333e-01],
[1.3036e-01, 8.2307e-01],
[2.5751e-01, 7.9255e-01],
[3.7833e-01, 7.4251e-01],
[4.8982e-01, 6.7418e-01],
[5.8926e-01, 5.8926e-01],
[6.7418e-01, 4.8982e-01],
[7.4251e-01, 3.7833e-01],
[7.9255e-01, 2.5751e-01],
[8.2307e-01, 1.3036e-01],
[8.3333e-01, 5.1027e-17],
[8.2307e-01, -1.3036e-01],
[7.9255e-01, -2.5751e-01],
[7.4251e-01, -3.7833e-01],
[6.7418e-01, -4.8982e-01],
[5.8926e-01, -5.8926e-01],
[4.8982e-01, -6.7418e-01],
[3.7833e-01, -7.4251e-01],
[2.5751e-01, -7.9255e-01],
[1.3036e-01, -8.2307e-01],
[1.0205e-16, -8.3333e-01],
[-1.3036e-01, -8.2307e-01],
[-2.5751e-01, -7.9255e-01],
[-3.7833e-01, -7.4251e-01],
[-4.8982e-01, -6.7418e-01],
[-5.8926e-01, -5.8926e-01],
[-6.7418e-01, -4.8982e-01],
[-7.4251e-01, -3.7833e-01],
[-7.9255e-01, -2.5751e-01],
[-8.2307e-01, -1.3036e-01],
[-8.3333e-01, -1.5308e-16],
[-8.2307e-01, 1.3036e-01],
[-7.9255e-01, 2.5751e-01],
[-7.4251e-01, 3.7833e-01],
[-6.7418e-01, 4.8982e-01],
[-5.8926e-01, 5.8926e-01],
[-4.8982e-01, 6.7418e-01],
[-3.7833e-01, 7.4251e-01],
[-2.5751e-01, 7.9255e-01],
[-1.3036e-01, 8.2307e-01],
[0.0000e+00, 9.1667e-01],
[1.3046e-01, 9.0734e-01],
[2.5825e-01, 8.7954e-01],
[3.8080e-01, 8.3383e-01],
[4.9559e-01, 7.7115e-01],
[6.0029e-01, 6.9277e-01],
[6.9277e-01, 6.0029e-01],
[7.7115e-01, 4.9559e-01],
[8.3383e-01, 3.8080e-01],
[8.7954e-01, 2.5825e-01],
[9.0734e-01, 1.3046e-01],
[9.1667e-01, 2.5967e-16],
[9.0734e-01, -1.3046e-01],
[8.7954e-01, -2.5825e-01],
[8.3383e-01, -3.8080e-01],
[7.7115e-01, -4.9559e-01],
[6.9277e-01, -6.0029e-01],
[6.0029e-01, -6.9277e-01],
[4.9559e-01, -7.7115e-01],
[3.8080e-01, -8.3383e-01],
[2.5825e-01, -8.7954e-01],
[1.3046e-01, -9.0734e-01],
[5.1934e-16, -9.1667e-01],
[-1.3046e-01, -9.0734e-01],
[-2.5825e-01, -8.7954e-01],
[-3.8080e-01, -8.3383e-01],
[-4.9559e-01, -7.7115e-01],
[-6.0029e-01, -6.9277e-01],
[-6.9277e-01, -6.0029e-01],
[-7.7115e-01, -4.9559e-01],
[-8.3383e-01, -3.8080e-01],
[-8.7954e-01, -2.5825e-01],
[-9.0734e-01, -1.3046e-01],
[-9.1667e-01, -1.6839e-16],
[-9.0734e-01, 1.3046e-01],
[-8.7954e-01, 2.5825e-01],
[-8.3383e-01, 3.8080e-01],
[-7.7115e-01, 4.9559e-01],
[-6.9277e-01, 6.0029e-01],
[-6.0029e-01, 6.9277e-01],
[-4.9559e-01, 7.7115e-01],
[-3.8080e-01, 8.3383e-01],
[-2.5825e-01, 8.7954e-01],
[-1.3046e-01, 9.0734e-01],
[0.0000e+00, 1.0000e+00],
[1.3053e-01, 9.9144e-01],
[2.5882e-01, 9.6593e-01],
[3.8268e-01, 9.2388e-01],
[5.0000e-01, 8.6603e-01],
[6.0876e-01, 7.9335e-01],
[7.0711e-01, 7.0711e-01],
[7.9335e-01, 6.0876e-01],
[8.6603e-01, 5.0000e-01],
[9.2388e-01, 3.8268e-01],
[9.6593e-01, 2.5882e-01],
[9.9144e-01, 1.3053e-01],
[1.0000e+00, 6.1232e-17],
[9.9144e-01, -1.3053e-01],
[9.6593e-01, -2.5882e-01],
[9.2388e-01, -3.8268e-01],
[8.6603e-01, -5.0000e-01],
[7.9335e-01, -6.0876e-01],
[7.0711e-01, -7.0711e-01],
[6.0876e-01, -7.9335e-01],
[5.0000e-01, -8.6603e-01],
[3.8268e-01, -9.2388e-01],
[2.5882e-01, -9.6593e-01],
[1.3053e-01, -9.9144e-01],
[1.2246e-16, -1.0000e+00],
[-1.3053e-01, -9.9144e-01],
[-2.5882e-01, -9.6593e-01],
[-3.8268e-01, -9.2388e-01],
[-5.0000e-01, -8.6603e-01],
[-6.0876e-01, -7.9335e-01],
[-7.0711e-01, -7.0711e-01],
[-7.9335e-01, -6.0876e-01],
[-8.6603e-01, -5.0000e-01],
[-9.2388e-01, -3.8268e-01],
[-9.6593e-01, -2.5882e-01],
[-9.9144e-01, -1.3053e-01],
[-1.0000e+00, -1.8370e-16],
[-9.9144e-01, 1.3053e-01],
[-9.6593e-01, 2.5882e-01],
[-9.2388e-01, 3.8268e-01],
[-8.6603e-01, 5.0000e-01],
[-7.9335e-01, 6.0876e-01],
[-7.0711e-01, 7.0711e-01],
[-6.0876e-01, 7.9335e-01],
[-5.0000e-01, 8.6603e-01],
[-3.8268e-01, 9.2388e-01],
[-2.5882e-01, 9.6593e-01],
[-1.3053e-01, 9.9144e-01]])
# 三角剖分后每个有限元的中心点坐标
self.tripoints = np.loadtxt(
r'D:\Proj\EIT\EIT-py\data\tripoints_mean_py.csv', delimiter=",")
# 边界值柱状图ax1的横轴标签
self.index_ls = [
'AB', 'AC', 'AD', 'AE', 'AF', 'AG', 'AH', 'BC', 'BD', 'BE', 'BF',
'BG', 'BH', 'CD', 'CE', 'CF', 'CG', 'CH', 'DE', 'DF', 'DG', 'DH',
'EF', 'EG', 'EH', 'FG', 'FH', 'GH'
]
# 反投影图ax3的标注
self.notate = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
# 8个电极的圆心角
self.theta = [
2 * np.pi / 4, 1 * np.pi / 4, 0 * np.pi / 4, 7 * np.pi / 4,
6 * np.pi / 4, 5 * np.pi / 4, 4 * np.pi / 4, 3 * np.pi / 4
]
# 生成三角剖分对象
self.triang = Triangulation(self.nodes[:, 0], self.nodes[:, 1])
self.trifinder = self.triang.get_trifinder()
# 图像显示色谱
self.cmap = plt.cm.RdBu_r
self.norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)
# ax1,ax2,ax3初始化
self.ax1_setup()
self.ax2_setup()
self.ax3_setup()
def ax1_setup(self):
"""ax1:边界数据柱状图"""
self.ax1 = self.fig.add_subplot(self.gs[0, :], aspect='auto')
plt.xticks(range(28), self.index_ls) #设置横坐标标签
plt.yticks([-10, 0, 10], c='none') #设置纵坐标刻度范围
plt.gca().xaxis.set_ticks_position('bottom')
plt.gca().spines['bottom'].set_position(('data', 0))
plt.gca().spines['right'].set_color('none')
plt.gca().spines['left'].set_color('none')
plt.gca().spines['top'].set_color('none')
def ax2_setup(self):
"""ax2:图像重建显示"""
self.ax2 = self.fig.add_subplot(self.gs[1:3, 0], aspect=1)
self.ax2.triplot(self.triang, linewidth=0.6, color='black') #绘制三角剖分网格
self.ax2.set_xticks([-1, 1])
self.ax2.set_yticks([-1, 1])
plt.axis('off')
self.cb = self.fig.colorbar(matplotlib.cm.ScalarMappable(
norm=self.norm, cmap="RdBu_r"),
ax=self.ax2) # 绘制色度条
self.cb.set_ticks([-1, 1])
def ax3_setup(self):
"""ax3:反投影路径"""
self.ax3 = self.fig.add_subplot(self.gs[1:3, 1],
projection='polar',
aspect=1)
for i in np.arange(8):
plt.annotate(self.notate[i],
xy=(self.theta[i], 1),
xytext=(self.theta[i], 1.1),
xycoords='data')
plt.axis('off')
def fe(self, elem_data):
"""以有限元填充方式显示重构图像"""
self.ax2.tripcolor(self.triang,
elem_data,
cmap="RdBu_r",
norm=self.norm,
shading='flat')
self.ax2.set_xticks([-1, 1])
self.ax2.set_yticks([-1, 1])
self.ax2.set_xticks([])
self.ax2.set_yticks([])
def interp(self, elem_data):
"""以矩阵插值方式显示重构图像"""
self.ax2.tripcolor(self.tripoints[:, 0],
self.tripoints[:, 1],
elem_data,
cmap="RdBu_r",
norm=self.norm,
shading='gouraud')
self.ax2.set_xticks([-1, 1])
self.ax2.set_yticks([-1, 1])
self.ax2.set_xticks([])
self.ax2.set_yticks([])
def contour(self, elem_data):
"""以轮廓图填充方式显示重构图像"""
self.ax2.tricontour(self.tripoints[:, 0],
self.tripoints[:, 1],
elem_data,
levels=5,
linewidths=0.5,
colors='k')
self.ax2.tricontourf(self.tripoints[:, 0],
self.tripoints[:, 1],
elem_data,
cmap="RdBu_r",
norm=self.norm,
levels=5)
self.ax2.set_xticks([-1, 1])
self.ax2.set_yticks([-1, 1])
self.ax2.set_xticks([])
self.ax2.set_yticks([])
def __init__(self, width, height, dpi):
self.fig = plt.figure(figsize=(width, height), dpi=dpi)
super(MyFigure, self).__init__(self.fig)
self.gs = GridSpec(3, 2) #画布布局
# 用于三角剖分的顶点坐标
self.nodes = np.array([[0.0000e+00, 0.0000e+00],
[0.0000e+00, 8.3333e-02],
[8.3333e-02, 5.1027e-18],
[1.0205e-17, -8.3333e-02],
[-8.3333e-02, -1.5308e-17],
[0.0000e+00, 1.6667e-01],
[1.1785e-01, 1.1785e-01],
[1.6667e-01, 1.0205e-17],
[1.1785e-01, -1.1785e-01],
[2.0411e-17, -1.6667e-01],
[-1.1785e-01, -1.1785e-01],
[-1.6667e-01, -3.0616e-17],
[-1.1785e-01, 1.1785e-01],
[0.0000e+00, 2.5000e-01],
[1.2500e-01, 2.1651e-01],
[2.1651e-01, 1.2500e-01],
[2.5000e-01, 1.5308e-17],
[2.1651e-01, -1.2500e-01],
[1.2500e-01, -2.1651e-01],
[3.0616e-17, -2.5000e-01],
[-1.2500e-01, -2.1651e-01],
[-2.1651e-01, -1.2500e-01],
[-2.5000e-01, -4.5924e-17],
[-2.1651e-01, 1.2500e-01],
[-1.2500e-01, 2.1651e-01],
[0.0000e+00, 3.3333e-01],
[1.2756e-01, 3.0796e-01],
[2.3570e-01, 2.3570e-01],
[3.0796e-01, 1.2756e-01],
[3.3333e-01, 2.0411e-17],
[3.0796e-01, -1.2756e-01],
[2.3570e-01, -2.3570e-01],
[1.2756e-01, -3.0796e-01],
[4.0822e-17, -3.3333e-01],
[-1.2756e-01, -3.0796e-01],
[-2.3570e-01, -2.3570e-01],
[-3.0796e-01, -1.2756e-01],
[-3.3333e-01, -6.1232e-17],
[-3.0796e-01, 1.2756e-01],
[-2.3570e-01, 2.3570e-01],
[-1.2756e-01, 3.0796e-01],
[0.0000e+00, 4.1667e-01],
[1.2876e-01, 3.9627e-01],
[2.4491e-01, 3.3709e-01],
[3.3709e-01, 2.4491e-01],
[3.9627e-01, 1.2876e-01],
[4.1667e-01, 2.5513e-17],
[3.9627e-01, -1.2876e-01],
[3.3709e-01, -2.4491e-01],
[2.4491e-01, -3.3709e-01],
[1.2876e-01, -3.9627e-01],
[5.1027e-17, -4.1667e-01],
[-1.2876e-01, -3.9627e-01],
[-2.4491e-01, -3.3709e-01],
[-3.3709e-01, -2.4491e-01],
[-3.9627e-01, -1.2876e-01],
[-4.1667e-01, -7.6540e-17],
[-3.9627e-01, 1.2876e-01],
[-3.3709e-01, 2.4491e-01],
[-2.4491e-01, 3.3709e-01],
[-1.2876e-01, 3.9627e-01],
[0.0000e+00, 5.0000e-01],
[1.2941e-01, 4.8296e-01],
[2.5000e-01, 4.3301e-01],
[3.5355e-01, 3.5355e-01],
[4.3301e-01, 2.5000e-01],
[4.8296e-01, 1.2941e-01],
[5.0000e-01, 3.0616e-17],
[4.8296e-01, -1.2941e-01],
[4.3301e-01, -2.5000e-01],
[3.5355e-01, -3.5355e-01],
[2.5000e-01, -4.3301e-01],
[1.2941e-01, -4.8296e-01],
[6.1232e-17, -5.0000e-01],
[-1.2941e-01, -4.8296e-01],
[-2.5000e-01, -4.3301e-01],
[-3.5355e-01, -3.5355e-01],
[-4.3301e-01, -2.5000e-01],
[-4.8296e-01, -1.2941e-01],
[-5.0000e-01, -9.1849e-17],
[-4.8296e-01, 1.2941e-01],
[-4.3301e-01, 2.5000e-01],
[-3.5355e-01, 3.5355e-01],
[-2.5000e-01, 4.3301e-01],
[-1.2941e-01, 4.8296e-01],
[0.0000e+00, 5.8333e-01],
[1.2980e-01, 5.6871e-01],
[2.5310e-01, 5.2557e-01],
[3.6370e-01, 4.5607e-01],
[4.5607e-01, 3.6370e-01],
[5.2557e-01, 2.5310e-01],
[5.6871e-01, 1.2980e-01],
[5.8333e-01, 3.5719e-17],
[5.6871e-01, -1.2980e-01],
[5.2557e-01, -2.5310e-01],
[4.5607e-01, -3.6370e-01],
[3.6370e-01, -4.5607e-01],
[2.5310e-01, -5.2557e-01],
[1.2980e-01, -5.6871e-01],
[7.1438e-17, -5.8333e-01],
[-1.2980e-01, -5.6871e-01],
[-2.5310e-01, -5.2557e-01],
[-3.6370e-01, -4.5607e-01],
[-4.5607e-01, -3.6370e-01],
[-5.2557e-01, -2.5310e-01],
[-5.6871e-01, -1.2980e-01],
[-5.8333e-01, -1.0716e-16],
[-5.6871e-01, 1.2980e-01],
[-5.2557e-01, 2.5310e-01],
[-4.5607e-01, 3.6370e-01],
[-3.6370e-01, 4.5607e-01],
[-2.5310e-01, 5.2557e-01],
[-1.2980e-01, 5.6871e-01],
[0.0000e+00, 6.6667e-01],
[1.3006e-01, 6.5386e-01],
[2.5512e-01, 6.1592e-01],
[3.7038e-01, 5.5431e-01],
[4.7140e-01, 4.7140e-01],
[5.5431e-01, 3.7038e-01],
[6.1592e-01, 2.5512e-01],
[6.5386e-01, 1.3006e-01],
[6.6667e-01, 4.0822e-17],
[6.5386e-01, -1.3006e-01],
[6.1592e-01, -2.5512e-01],
[5.5431e-01, -3.7038e-01],
[4.7140e-01, -4.7140e-01],
[3.7038e-01, -5.5431e-01],
[2.5512e-01, -6.1592e-01],
[1.3006e-01, -6.5386e-01],
[8.1643e-17, -6.6667e-01],
[-1.3006e-01, -6.5386e-01],
[-2.5512e-01, -6.1592e-01],
[-3.7038e-01, -5.5431e-01],
[-4.7140e-01, -4.7140e-01],
[-5.5431e-01, -3.7038e-01],
[-6.1592e-01, -2.5512e-01],
[-6.5386e-01, -1.3006e-01],
[-6.6667e-01, -1.2246e-16],
[-6.5386e-01, 1.3006e-01],
[-6.1592e-01, 2.5512e-01],
[-5.5431e-01, 3.7038e-01],
[-4.7140e-01, 4.7140e-01],
[-3.7038e-01, 5.5431e-01],
[-2.5512e-01, 6.1592e-01],
[-1.3006e-01, 6.5386e-01],
[0.0000e+00, 7.5000e-01],
[1.3024e-01, 7.3861e-01],
[2.5652e-01, 7.0477e-01],
[3.7500e-01, 6.4952e-01],
[4.8209e-01, 5.7453e-01],
[5.7453e-01, 4.8209e-01],
[6.4952e-01, 3.7500e-01],
[7.0477e-01, 2.5652e-01],
[7.3861e-01, 1.3024e-01],
[7.5000e-01, 4.5924e-17],
[7.3861e-01, -1.3024e-01],
[7.0477e-01, -2.5652e-01],
[6.4952e-01, -3.7500e-01],
[5.7453e-01, -4.8209e-01],
[4.8209e-01, -5.7453e-01],
[3.7500e-01, -6.4952e-01],
[2.5652e-01, -7.0477e-01],
[1.3024e-01, -7.3861e-01],
[9.1849e-17, -7.5000e-01],
[-1.3024e-01, -7.3861e-01],
[-2.5652e-01, -7.0477e-01],
[-3.7500e-01, -6.4952e-01],
[-4.8209e-01, -5.7453e-01],
[-5.7453e-01, -4.8209e-01],
[-6.4952e-01, -3.7500e-01],
[-7.0477e-01, -2.5652e-01],
[-7.3861e-01, -1.3024e-01],
[-7.5000e-01, -1.3777e-16],
[-7.3861e-01, 1.3024e-01],
[-7.0477e-01, 2.5652e-01],
[-6.4952e-01, 3.7500e-01],
[-5.7453e-01, 4.8209e-01],
[-4.8209e-01, 5.7453e-01],
[-3.7500e-01, 6.4952e-01],
[-2.5652e-01, 7.0477e-01],
[-1.3024e-01, 7.3861e-01],
[0.0000e+00, 8.3333e-01],
[1.3036e-01, 8.2307e-01],
[2.5751e-01, 7.9255e-01],
[3.7833e-01, 7.4251e-01],
[4.8982e-01, 6.7418e-01],
[5.8926e-01, 5.8926e-01],
[6.7418e-01, 4.8982e-01],
[7.4251e-01, 3.7833e-01],
[7.9255e-01, 2.5751e-01],
[8.2307e-01, 1.3036e-01],
[8.3333e-01, 5.1027e-17],
[8.2307e-01, -1.3036e-01],
[7.9255e-01, -2.5751e-01],
[7.4251e-01, -3.7833e-01],
[6.7418e-01, -4.8982e-01],
[5.8926e-01, -5.8926e-01],
[4.8982e-01, -6.7418e-01],
[3.7833e-01, -7.4251e-01],
[2.5751e-01, -7.9255e-01],
[1.3036e-01, -8.2307e-01],
[1.0205e-16, -8.3333e-01],
[-1.3036e-01, -8.2307e-01],
[-2.5751e-01, -7.9255e-01],
[-3.7833e-01, -7.4251e-01],
[-4.8982e-01, -6.7418e-01],
[-5.8926e-01, -5.8926e-01],
[-6.7418e-01, -4.8982e-01],
[-7.4251e-01, -3.7833e-01],
[-7.9255e-01, -2.5751e-01],
[-8.2307e-01, -1.3036e-01],
[-8.3333e-01, -1.5308e-16],
[-8.2307e-01, 1.3036e-01],
[-7.9255e-01, 2.5751e-01],
[-7.4251e-01, 3.7833e-01],
[-6.7418e-01, 4.8982e-01],
[-5.8926e-01, 5.8926e-01],
[-4.8982e-01, 6.7418e-01],
[-3.7833e-01, 7.4251e-01],
[-2.5751e-01, 7.9255e-01],
[-1.3036e-01, 8.2307e-01],
[0.0000e+00, 9.1667e-01],
[1.3046e-01, 9.0734e-01],
[2.5825e-01, 8.7954e-01],
[3.8080e-01, 8.3383e-01],
[4.9559e-01, 7.7115e-01],
[6.0029e-01, 6.9277e-01],
[6.9277e-01, 6.0029e-01],
[7.7115e-01, 4.9559e-01],
[8.3383e-01, 3.8080e-01],
[8.7954e-01, 2.5825e-01],
[9.0734e-01, 1.3046e-01],
[9.1667e-01, 2.5967e-16],
[9.0734e-01, -1.3046e-01],
[8.7954e-01, -2.5825e-01],
[8.3383e-01, -3.8080e-01],
[7.7115e-01, -4.9559e-01],
[6.9277e-01, -6.0029e-01],
[6.0029e-01, -6.9277e-01],
[4.9559e-01, -7.7115e-01],
[3.8080e-01, -8.3383e-01],
[2.5825e-01, -8.7954e-01],
[1.3046e-01, -9.0734e-01],
[5.1934e-16, -9.1667e-01],
[-1.3046e-01, -9.0734e-01],
[-2.5825e-01, -8.7954e-01],
[-3.8080e-01, -8.3383e-01],
[-4.9559e-01, -7.7115e-01],
[-6.0029e-01, -6.9277e-01],
[-6.9277e-01, -6.0029e-01],
[-7.7115e-01, -4.9559e-01],
[-8.3383e-01, -3.8080e-01],
[-8.7954e-01, -2.5825e-01],
[-9.0734e-01, -1.3046e-01],
[-9.1667e-01, -1.6839e-16],
[-9.0734e-01, 1.3046e-01],
[-8.7954e-01, 2.5825e-01],
[-8.3383e-01, 3.8080e-01],
[-7.7115e-01, 4.9559e-01],
[-6.9277e-01, 6.0029e-01],
[-6.0029e-01, 6.9277e-01],
[-4.9559e-01, 7.7115e-01],
[-3.8080e-01, 8.3383e-01],
[-2.5825e-01, 8.7954e-01],
[-1.3046e-01, 9.0734e-01],
[0.0000e+00, 1.0000e+00],
[1.3053e-01, 9.9144e-01],
[2.5882e-01, 9.6593e-01],
[3.8268e-01, 9.2388e-01],
[5.0000e-01, 8.6603e-01],
[6.0876e-01, 7.9335e-01],
[7.0711e-01, 7.0711e-01],
[7.9335e-01, 6.0876e-01],
[8.6603e-01, 5.0000e-01],
[9.2388e-01, 3.8268e-01],
[9.6593e-01, 2.5882e-01],
[9.9144e-01, 1.3053e-01],
[1.0000e+00, 6.1232e-17],
[9.9144e-01, -1.3053e-01],
[9.6593e-01, -2.5882e-01],
[9.2388e-01, -3.8268e-01],
[8.6603e-01, -5.0000e-01],
[7.9335e-01, -6.0876e-01],
[7.0711e-01, -7.0711e-01],
[6.0876e-01, -7.9335e-01],
[5.0000e-01, -8.6603e-01],
[3.8268e-01, -9.2388e-01],
[2.5882e-01, -9.6593e-01],
[1.3053e-01, -9.9144e-01],
[1.2246e-16, -1.0000e+00],
[-1.3053e-01, -9.9144e-01],
[-2.5882e-01, -9.6593e-01],
[-3.8268e-01, -9.2388e-01],
[-5.0000e-01, -8.6603e-01],
[-6.0876e-01, -7.9335e-01],
[-7.0711e-01, -7.0711e-01],
[-7.9335e-01, -6.0876e-01],
[-8.6603e-01, -5.0000e-01],
[-9.2388e-01, -3.8268e-01],
[-9.6593e-01, -2.5882e-01],
[-9.9144e-01, -1.3053e-01],
[-1.0000e+00, -1.8370e-16],
[-9.9144e-01, 1.3053e-01],
[-9.6593e-01, 2.5882e-01],
[-9.2388e-01, 3.8268e-01],
[-8.6603e-01, 5.0000e-01],
[-7.9335e-01, 6.0876e-01],
[-7.0711e-01, 7.0711e-01],
[-6.0876e-01, 7.9335e-01],
[-5.0000e-01, 8.6603e-01],
[-3.8268e-01, 9.2388e-01],
[-2.5882e-01, 9.6593e-01],
[-1.3053e-01, 9.9144e-01]])
# 三角剖分后每个有限元的中心点坐标
self.tripoints = np.loadtxt(
r'D:\Proj\EIT\EIT-py\data\tripoints_mean_py.csv', delimiter=",")
# 边界值柱状图ax1的横轴标签
self.index_ls = [
'AB', 'AC', 'AD', 'AE', 'AF', 'AG', 'AH', 'BC', 'BD', 'BE', 'BF',
'BG', 'BH', 'CD', 'CE', 'CF', 'CG', 'CH', 'DE', 'DF', 'DG', 'DH',
'EF', 'EG', 'EH', 'FG', 'FH', 'GH'
]
# 反投影图ax3的标注
self.notate = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
# 8个电极的圆心角
self.theta = [
2 * np.pi / 4, 1 * np.pi / 4, 0 * np.pi / 4, 7 * np.pi / 4,
6 * np.pi / 4, 5 * np.pi / 4, 4 * np.pi / 4, 3 * np.pi / 4
]
# 生成三角剖分对象
self.triang = Triangulation(self.nodes[:, 0], self.nodes[:, 1])
self.trifinder = self.triang.get_trifinder()
# 图像显示色谱
self.cmap = plt.cm.RdBu_r
self.norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)
# ax1,ax2,ax3初始化
self.ax1_setup()
self.ax2_setup()
self.ax3_setup()
n_radii = 10 min_radius = 0.15 radii = np.linspace(min_radius, 0.95, n_radii) angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False) angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1) angles[:, 1::2] += math.pi/n_angles x = (radii*np.cos(angles)).flatten() y = (radii*np.sin(angles)).flatten() z = function_z(x, y) # Now create the Triangulation. # (Creating a Triangulation without specifying the triangles results in the # Delaunay triangulation of the points.) triang = Triangulation(x, y) # Mask off unwanted triangles. xmid = x[triang.triangles].mean(axis=1) ymid = y[triang.triangles].mean(axis=1) mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0) triang.set_mask(mask) #----------------------------------------------------------------------------- # Refine data #----------------------------------------------------------------------------- refiner = UniformTriRefiner(triang) tri_refi, z_test_refi = refiner.refine_field(z, subdiv=3) #----------------------------------------------------------------------------- # Plot the triangulation and the high-res iso-contours
update_polygon(tri)
plt.title('In triangle %i' % tri)
event.canvas.draw()
# Create a Triangulation.
n_angles = 16
n_radii = 5
min_radius = 0.25
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += math.pi / n_angles
x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
triangulation = Triangulation(x, y)
xmid = x[triangulation.triangles].mean(axis=1)
ymid = y[triangulation.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triangulation.set_mask(mask)
# Use the triangulation's default TriFinder object.
trifinder = triangulation.get_trifinder()
# Setup plot and callbacks.
plt.subplot(111, aspect='equal')
plt.triplot(triangulation, 'bo-')
polygon = Polygon([[0, 0], [0, 0]], facecolor='y') # dummy data for xs,ys
update_polygon(-1)
plt.gca().add_patch(polygon)
plt.gcf().canvas.mpl_connect('motion_notify_event', motion_notify)
# for k in range(0,theta.shape[0]):
# if k < N:
# phi[k,:] = 1.57
# else:
# phi[k,:] = phiTwist[k-N]
# radius in x-y plane
r = 1 + w * np.cos(phi)
x = np.ravel(r * np.cos(theta))
y = np.ravel(r * np.sin(theta))
z = np.ravel(w * np.sin(phi))
# triangulate in the underlying parametrization
tri = Triangulation(np.ravel(w), np.ravel(theta))
ax = plt.axes(projection='3d')
ax.plot_trisurf(x, y, z, triangles=tri.triangles,
edgecolor='none', color='grey', linewidths=0,
alpha=0.5);
# x_middle = np.ravel(r_middle * np.cos(theta_middle))
# y_middle = np.ravel(r_middle * np.sin(theta_middle))
# z_middle = np.ravel(w_middle * np.sin(phi_middle))
x_middle = np.ravel(np.cos(theta))
y_middle = np.ravel(np.sin(theta))
z_middle = np.ravel(0. * np.sin(phi))
plt.plot(x_middle,y_middle,z_middle,'-m',lw=5)
plt.plot([1,-1],[0,0],[0,0.5],'og', markersize=5)
# (invalid) initial triangles which will be masked
# out. Enter 0 for no mask.
min_circle_ratio = .01 # Minimum circle ratio - border triangles with circle
# ratio below this will be masked if they touch a
# border. Suggested value 0.01 ; Use -1 to keep
# all triangles.
# Random points
random_gen = np.random.mtrand.RandomState(seed=127260)
x_test = random_gen.uniform(-1., 1., size=n_test)
y_test = random_gen.uniform(-1., 1., size=n_test)
z_test = experiment_res(x_test, y_test)
# meshing with Delaunay triangulation
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]
# Some invalid data are masked out
mask_init = np.zeros(ntri, dtype=np.bool)
masked_tri = random_gen.randint(0, ntri, int(ntri*init_mask_frac))
mask_init[masked_tri] = True
tri.set_mask(mask_init)
#-----------------------------------------------------------------------------
# Improving the triangulation before high-res plots: removing flat triangles
#-----------------------------------------------------------------------------
# masking badly shaped triangles at the border of the triangular mesh.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)
)
# {{{ generate the surface plot using fancy methods for a nice plot
# creates the Delauney meshing
tri_y = t_axis.ravel()
tri_x = ((f_axis[:,newaxis]*ones_like(t_axis)).ravel()
-f_axis.mean())/1e3
tri_z = rx_axis.ravel()
# {{{ this part is actually very important, and prevents the data from
# interpolating to 0 at the edges!
# --> in the future, note that nan is a good placeholder for "lack of data"
mask = tri_y == 0 # t=0 are not valid datapoints
tri_y = tri_y[~mask]
tri_x = tri_x[~mask]
tri_z = tri_z[~mask]
# }}}
tri = Triangulation(tri_x,
tri_y)
# {{{ refining the data -- see https://matplotlib.org/3.1.0/gallery/images_contours_and_fields/tricontour_smooth_delaunay.html#sphx-glr-gallery-images-contours-and-fields-tricontour-smooth-delaunay-py
# I don't see a difference in the refined (tri_refi) vs. unrefined (tri),
# but I'm quite possibly missing something, or it's more helpful in other cases
refiner = UniformTriRefiner(tri)
subdiv = 3 # Number of recursive subdivisions of the initial mesh for smooth
# plots. Values >3 might result in a very high number of triangles
# for the refine mesh: new triangles numbering = (4**subdiv)*ntri
tri_refi, tri_z_refi = refiner.refine_field(tri_z, subdiv=subdiv)
mask = TriAnalyzer(tri_refi).get_flat_tri_mask(10)
tri_refi = tri_refi.set_mask(~mask)
# }}}
figure(figsize=(5,15),
facecolor=(1,1,1,0))
if not presentation:
plot(tri_x,tri_y,'o',
def plot_data(self, ax, column_prefix, offset=None):
# default value workaround
if offset is None:
offset = self.n
if offset > 0:
data_portion = self.df[:offset]
if self.drop_yearly and offset > 0:
current_date = self.df.loc[offset - 1]['date']
year_mask = data_portion['date'].apply(
lambda x: (current_date - x).days <= 365.25)
data_portion = data_portion[year_mask]
titles = [column_prefix + "_t" + str(i) for i in range(3)]
# set the axial labesl
ax.set_xlabel(titles[0])
ax.set_ylabel(titles[1])
ax.set_zlabel(titles[2])
# generate the size of the dots (vector of size^2)
size = 7 * np.ones(len(data_portion))
if self.coloring == Coloring.DISCRETE_MONTHS_SPLIT_MARKERS or self.coloring == Coloring.DISCRETE_MONTHS_POLYGONS:
d = {
"1 2 3": ("+", 'b'),
"4 5 6": ("o", 'g'),
"7 8 9": ("^", 'r'),
"10 11 12": ("D", 'y')
}
for vals, (split_marker, color) in d.items():
mask = data_portion['date'].apply(
lambda x: x.month in map(int, vals.split(" ")))
adf = data_portion[mask]
# get the actual columns
xs = adf[titles[0]]
ys = adf[titles[1]]
zs = adf[titles[2]]
if self.coloring == Coloring.DISCRETE_MONTHS_POLYGONS:
try:
X = np.array(list(zip(xs, ys, zs)))
if len(X) > 4:
cvx = ConvexHull(X)
tri = Triangulation(xs,
ys,
triangles=cvx.simplices)
ax.plot_trisurf(tri,
zs,
alpha=0.2,
color=color)
except Exception:
print("Couldn't draw convex hull")
if self.coloring == Coloring.DISCRETE_MONTHS_SPLIT_MARKERS:
marker = split_marker
else:
marker = 'o'
ax.scatter(xs,
ys,
zs,
marker=marker,
s=size[mask],
c=color)
else:
xs = data_portion[titles[0]]
ys = data_portion[titles[1]]
zs = data_portion[titles[2]]
if self.drop_yearly:
ax.scatter(xs,
ys,
zs,
marker="o",
s=size,
c=self.colors[:offset][year_mask])
else:
ax.scatter(xs,
ys,
zs,
marker="o",
s=size,
c=self.colors[:offset])
ax.set_title(self.caretype + " " + column_prefix.capitalize())
# (invalid) initial triangles which will be masked
# out. Enter 0 for no mask.
min_circle_ratio = .01 # Minimum circle ratio - border triangles with circle
# ratio below this will be masked if they touch a
# border. Suggested value 0.01; use -1 to keep
# all triangles.
# Random points
random_gen = np.random.RandomState(seed=19680801)
x_test = random_gen.uniform(-1., 1., size=n_test)
y_test = random_gen.uniform(-1., 1., size=n_test)
z_test = experiment_res(x_test, y_test)
# meshing with Delaunay triangulation
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]
# Some invalid data are masked out
mask_init = np.zeros(ntri, dtype=bool)
masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
mask_init[masked_tri] = True
tri.set_mask(mask_init)
#-----------------------------------------------------------------------------
# Improving the triangulation before high-res plots: removing flat triangles
#-----------------------------------------------------------------------------
# masking badly shaped triangles at the border of the triangular mesh.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)
class BaseTrig:
"""" Base class to be inherited by CTrig (charges) and GTrig (FE calculation). The class handles loading
the triangulation, calculating relevant fields and plotting. Has two plotting functions: heatmap to
plot spatially varying fields and boundary_plot to plot just the boundary.
"""
def __init__(self, lattice, p, method):
self.method = method
self.lattice = lattice
self.p = p # porosity
self.holes = None # list of hole positions
self.boundary = None
self.N_holes = None
self.tri = None # A matplotlib Tri object.
self.real_nodes = None
self.mask = None # mask for Tri object, specifies which nodes to plot.
self.length_factor = None
def calc_tri(self):
self.N_holes = self.holes.shape[1]
self.tri = Triangulation(*self.lagrange_nodes(only_real=False))
self._set_mask()
def _set_mask(self, crop=np.inf):
# mask tris which involve a hole
c1 = self.tri.triangles.min(axis=1) <= self.N_holes
# mask tris with points outside crop
c2 = np.abs(self.tri.x[self.tri.triangles]).max(axis=1) > crop
c3 = np.abs(self.tri.y[self.tri.triangles]).max(axis=1) > crop
self.mask = c1 | c2 | c3
self.tri.set_mask(self.mask)
def lagrange_nodes(self, only_real=True):
if only_real:
return self.real_nodes
else:
return np.c_[self.holes, self.real_nodes]
def euler_nodes(self, only_real=True):
nodes = np.array([self.tri.x, self.tri.y])
if only_real:
nodes = nodes[:, self.N_holes:]
return nodes
def deform(self, strain, kind='lin'):
"""
Deforms the mesh. Kind specifiec by which field to deform the mesh. It can be either 'lin'
for linear response or 'mode' for most unstable mode. strain is the amplitude.
"""
if 'linear'.startswith(kind):
H = self.lagrange_nodes()[1].max() - self.lagrange_nodes()[1].min()
scale = H * strain / 2
sol = scale * self.d_lin
self.stress *= scale
elif 'mode'.startswith(kind):
sol = strain * self.d_mode
else:
raise ValueError(f'didnt understand kind={kind}')
all_nodes = self.lagrange_nodes(only_real=False)
self.tri.x = all_nodes[0] + self.append_shit(sol[0])
self.tri.y = all_nodes[1] + self.append_shit(sol[1])
def heatmap(self,
c,
ax=None,
cbar=True,
cmap=None,
clim=None,
cax=None,
crop=None):
if ax is None:
ax = plt.gca()
single_color = c is None
if single_color:
c = np.full_like(self.lagrange_nodes()[0], 0)
clim = [-1, 1]
color = (0.2980392156862745, 0.4470588235294118,
0.6901960784313725)
cmap = mpl.colors.ListedColormap((color, color))
if clim is None:
levels = np.linspace(c.min(), c.max(), 20)
else:
levels = np.linspace(*clim, 20)
if crop:
self._set_mask(crop)
if cmap is None and not single_color:
cmap = sns.color_palette("RdBu_r", 20)
cmap = mpl.colors.ListedColormap(cmap)
hf = ax.tricontourf(self.tri,
self.append_shit(c),
levels=levels,
cmap=cmap)
if not single_color:
hc = ax.tricontour(self.tri,
self.append_shit(c),
levels=levels,
colors=['0.25', '0.5', '0.5', '0.5', '0.5'],
linewidths=[1.0, 0.5, 0.5, 0.5, 0.5])
ax.set_aspect(1)
ax.axis('off')
if cbar:
if cax is None:
cbar = plt.colorbar(hf, ax=ax)
else:
cbar = plt.colorbar(hf, cax=cax)
return ax, cbar
def boundary_plot(self,
deformation='mode',
fill=True,
scale=1,
ax=None,
facecolor='b',
edgecolor='None',
alpha=1,
skip=1):
if deformation == 'mode':
d = self.d_mode[:, self.boundary]
elif deformation == 'lin':
d = self.d_lin[:, self.boundary]
if ax is None:
ax = plt.gca()
reference = self.lagrange_nodes()[:, self.boundary]
if hasattr(self, 'cyc'):
cyc = self.cyc
else:
print('no cyclifier, calculating')
cyc = Cyclifier(reference)
self.cyc = cyc
print('done')
pos = reference + scale * d
patch = patchify(cyc(pos, as_patches=True, skip=skip))
patch.set_facecolor(facecolor)
patch.set_edgecolor(edgecolor)
patch.set_alpha(alpha)
patch = ax.add_patch(patch)
ax.axis('off')
ax.set_xticks([])
ax.set_yticks([])
ax.axis('equal')
return patch
def append_shit(self, x, fill_value=None):
"""Prepend zeros to x on hole nodes."""
assert x.ndim == 1
if hasattr(x, 'values'):
x = x.values
if fill_value is None:
fill = x.mean().astype(x.dtype)
else:
fill = fill_value
return np.r_[fill + np.zeros(self.N_holes, dtype=x.dtype), x]
@property
def sxy(self):
return self.stress[2]
@property
def syy(self):
return self.stress[1]
@property
def sxx(self):
return self.stress[0]
def griddata_nn_delaunay(x,y,z,xi,yi):
"""Like matplotlib.mlab.griddata() but strictly using delaunay"""
tri = Triangulation(x,y)
interp = tri.nn_interpolator(z)
return np.ma.masked_invalid(interp(xi,yi))
# 在下方设置选取固定范围阈值
layer.SetAttributeFilter("Velocity <= -110")
l = len(layer)
a = np.empty([l, 3])
i = 0
for feature in layer:
a[i,0] = feature.GetField("X")
a[i, 1] = feature.GetField("Y")
a[i, 2] = feature.GetField("Velocity")
# a[i, 2] = 1
i = i+1
x_test=a[:,0]
y_test=a[:,1]
z_test=a[:,2]
tri = Triangulation(x_test, y_test)
# nedge = tri.edges.shape[0]
# l = tri.edges
#
# n = np.hypot(x_test[l[:,0]],x_test[l[:,1]])
# m = np.hypot(y_test[l[:,0]],y_test[l[:,1]])
# d = np.sqrt(n**2 + m**2)
a = tri.triangles
b1 = x_test[tri.triangles]
b2 = y_test[tri.triangles]
num = b1.shape[0]
c1 = np.empty([num,3])
c2 = np.empty([num,3])
for i in range (num):
c1[i, 0] = b1[i, 0] - b1[i, 1] # X
c1[i, 1] = b1[i, 1] - b1[i, 2]
def calc_tri(self):
self.N_holes = self.holes.shape[1]
self.tri = Triangulation(*self.lagrange_nodes(only_real=False))
self._set_mask()
def plot(self, subdivisions=None):
"""Plot the value of this :class:`Function`. This is quite a low
performance plotting routine so it will perform poorly on
larger meshes, but it has the advantage of supporting higher
order function spaces than many widely available libraries.
:param subdivisions: The number of points in each direction to
use in representing each element. The default is
:math:`2d+1` where :math:`d` is the degree of the
:class:`FunctionSpace`. Higher values produce prettier plots
which render more slowly!
"""
fs = self.function_space
if isinstance(fs.element, VectorFiniteElement):
coords = Function(fs)
coords.interpolate(lambda x: x)
fig = plt.figure()
ax = fig.gca()
x = coords.values.reshape(-1, 2)
v = self.values.reshape(-1, 2)
plt.quiver(x[:, 0], x[:, 1], v[:, 0], v[:, 1])
plt.show()
return
d = subdivisions or (2 * (fs.element.degree + 1)
if fs.element.degree > 1 else 2)
if fs.element.cell is ReferenceInterval:
fig = plt.figure()
fig.add_subplot(111)
# Interpolation rule for element values.
local_coords = lagrange_points(fs.element.cell, d)
elif fs.element.cell is ReferenceTriangle:
fig = plt.figure()
ax = fig.gca(projection='3d')
local_coords, triangles = self._lagrange_triangles(d)
else:
raise ValueError("Unknown reference cell: %s" % fs.element.cell)
function_map = fs.element.tabulate(local_coords)
# Interpolation rule for coordinates.
cg1 = LagrangeElement(fs.element.cell, 1)
coord_map = cg1.tabulate(local_coords)
cg1fs = FunctionSpace(fs.mesh, cg1)
for c in range(fs.mesh.entity_counts[-1]):
vertex_coords = fs.mesh.vertex_coords[cg1fs.cell_nodes[c, :], :]
x = np.dot(coord_map, vertex_coords)
local_function_coefs = self.values[fs.cell_nodes[c, :]]
v = np.dot(function_map, local_function_coefs)
if fs.element.cell is ReferenceInterval:
plt.plot(x[:, 0], v, 'k')
else:
ax.plot_trisurf(Triangulation(x[:, 0], x[:, 1], triangles),
v,
linewidth=0)
plt.show()
def gen_map(request, *configs):
start = datetime.datetime.now()
"""
example URL: http://127.0.0.1:8000/ice_oceanapi/120/122/26.5/28.5/
:param request:The page sent the GET content request
:return:HttpResponse object
"""
if request.method == 'GET':
if configs:
# 类型名称
type_name = request.POST.get('type_name')
# 类型排序
type_sort = request.POST.get('type_sort')
current_path = os.path.dirname(os.path.abspath(__file__))
project_path = os.path.abspath(os.path.join(current_path, '../'))
# print(project_path)
# https://plot.ly/python/surface-triangulation/
# https://www.hatarilabs.com/ih-en/triangular-mesh-for-groundwater-models-with-modflow-6-and-flopy-tutorial
"""
param extent : 确定显示区域
param file : 输入文件
"""
extent = [
float(configs[0]),
float(configs[1]),
float(configs[2]),
float(configs[3])
]
# extent = [120, 122, 26.5, 28.5]
# 根据显示范围对图像长宽进行调整
x_length = extent[0] - extent[1]
y_length = extent[2] - extent[3]
rat = x_length / y_length
f1 = plt.figure(figsize=(5, 5 * rat))
ax = f1.add_subplot(111, projection=ccrs.PlateCarree())
canvas = f1.canvas
# 窗口调整
ax.axis('off')
ax.set_position([0, 0, 1, 1])
ax.set_extent(extent)
for spine in ax.spines.values():
spine.set_visible(False)
ax.background_patch.set_visible(False)
ax.outline_patch.set_visible(False)
ax.set_xlim(extent[0], extent[1])
ax.set_ylim(extent[2], extent[3])
ax.patch.set_alpha(0.)
# 首先需要了解的是，加在特定的环境进行数据读取
triangles_2dm = []
position = []
file = 'data_depth/NSwz_001E.2dm'
meshfile = Mesh(file)
# print('totally time is ' + str(datetime.datetime.now() - start))
for index in range(0, len(meshfile.ED)):
xx = [int(values) - 1 for values in meshfile.ED[index][2:5]]
triangles_2dm.append(xx)
tri = Triangulation(meshfile.lon,
meshfile.lat,
triangles=triangles_2dm)
# 调整水深
levels = np.arange(0., 120., 10.0)
# 颜色调整
cmap = cm.get_cmap(name='Blues', lut=None)
# 画图
cntr2 = ax.tricontourf(tri,
meshfile.h,
levels=levels,
cmap=cmap,
transform=ccrs.PlateCarree())
# 第一种保存方式（直接对plt 进行保存）
# 保存图片
# plt.savefig("ice_ocean\\media\\07192.png", dpi=144, bbox_inches=0.0, transparent=True, profile='tiny')
# 第二种保存方式（获取Plt的数据并使用cv2进行保存）
buffer = io.BytesIO() # 获取输入输出流对象
canvas.print_png(buffer) # 将画布上的内容打印到输入输出流对象
data = buffer.getvalue() # 获取流的值
# print("plt的二进制流为:\n", data)
# buffer.write(data) # 将数据写入buffer
# img = Image.open(buffer) # 使用Image打开图片数据
# img = np.asarray(img)
# print("转换的图片array为:\n", img)
buffer.close()
result = ""
print('totally time is ' + str(datetime.datetime.now() - start))
print("{0}".format(result))
return HttpResponse(data, content_type='image/png')
else:
return HttpResponse('configs are wrong.')
elif request.method == 'POST':
return HttpResponse('Method is wrong.')
else:
return HttpResponse('What are you doing?')
#莫比乌斯带
u = np.linspace(0, 2 * np.pi, 30)
v = np.linspace(-0.5, 0.5, 8) / 2.0
v, u = np.meshgrid(v, u)
phi = 0.5 * u
phi
r = 1 + v * np.cos(phi)
x = np.ravel(r * np.cos(u)) #范围一维数组
y = np.ravel(r * np.sin(u))
z = np.ravel(v * np.sin(phi))
from matplotlib.tri import Triangulation
#matplotlib.tri专门针对非结构化网络作图的模块，Triangulation实现元素为三角形的非机构化网络
tri = Triangulation(np.ravel(v), np.ravel(u))
ax = plt.axes(projection='3d')
ax.plot_trisurf(x,
y,
z,
triangles=tri.triangles,
cmap='viridis',
linewidths=0.2)
ax.set_xlim(-1, 1)
ax.set_ylim(-1, 1)
ax.set_zlim(-1, 1)
# In[42]:
def makeLiftTriangles(self):
# Inizializzazione liste dei triangoli di sollevamento e relativi vertici.
VSollTrList = []
VSollVxList = []
TSollTrList = []
TSollVxList = []
TSollLabels = [] # lista di pedici dei vertici per i triangoli TSoll.
ESollVxList = []
ESollLabels = []
# TSollFinder e' un dizionario tale da associare ad ogni coppia (n,i), dove n e 'un triangolo della triangolazione di partenza e V_i un suo vertice, la posizione in TSollTr del triangolo di sollevamento corrispondente.
self.TSollFinder = {}
# Inizializzazione liste dei coefficienti sigma.
# TSollSigma[m] = sigma_m^t;
# BESollSigma[i,j] = sigma_(i,j)^e
self.TSollSigma = {}
self.ESollSigma = {}
# Inizializzazione del dizionario dei coefficienti alpha.
# alpha[i][j] = alpha_i,(j+1) j=0,1,2;
# alpha[i][j] = alpha^x_i,(j-2) j=3,4,5;
# alpha[i][j] = alpha^y_i,(j-5) j=6,7,8.
self.alpha = {}
# Triangoli di sollevamento associati ai vertici.
for i in range(len(self.domain.startPoints)):
# Ricavo il triangolo per il vertice corrente.
liftTr = self.findVertexLiftTriangle(i)
# Aggiungo punti e triangolo in lista.
codTr = []
for pt in liftTr:
VSollVxList.append(pt)
codTr.append(len(VSollVxList) - 1)
VSollTrList.append(np.array(codTr))
# Creo la triangolazione contenente i triangoli di sollevamento associati ai vertici.
self.VSollVx = np.array(VSollVxList)
self.VSollTr = np.array(VSollTrList)
self.VSoll = Triangulation(self.VSollVx[:, 0], self.VSollVx[:, 1],
self.VSollTr)
# Triangoli di sollevamento associati alla triangolazione.
for n in range(len(self.domain.startTr.triangles)):
for i in self.domain.startTr.triangles[n]:
codTr = []
# Aggiungo il punto S_{i,n}^t.
TSollVxList.append(2 / 3 * self.domain.startPoints[i] +
1 / 3 * self.domain.incenters[n])
TSollLabels.append('$S^t_{' + str(i + 1) + ',' + str(n + 1) +
'}$')
codTr.append(len(TSollVxList) - 1)
# Ricerca dei triangoli PS m e m' a vertice V_i.
mList, jList = self.getPSTriangles(n, i)
# Calcolo i coefficienti sigma^t.
mx = max(
self.domain.xi[n, jList[0]] / self.domain.lamb[jList[0], i]
+ self.domain.xi[n, jList[1]] /
self.domain.lamb[jList[1], i], 1)
for l in range(2):
self.TSollSigma[mList[l]] = self.domain.lamb[jList[l],
i] / 2 * mx
# Aggiunta dei punti Q_m^t e Q_m'^t.
for l in range(2):
TSollVxList.append(TSollVxList[len(TSollVxList) - 1 - l] +
2 / 3 * self.TSollSigma[mList[l]] *
(self.domain.startPoints[jList[l]] -
self.domain.startPoints[i]))
TSollLabels.append('$Q^t_{' + str(mList[l] + 1) + '}$')
codTr.append(len(TSollVxList) - 1)
# Aggiunta del triangolo di sollevamento e aggiornamento di TSollFinder.
TSollTrList.append(np.array(codTr))
self.TSollFinder[n, i] = len(TSollTrList) - 1
# Creo la triangolazione contenente i triangoli di sollevamento associati ai vertici.
self.TSollVx = np.array(TSollVxList)
self.TSollTr = np.array(TSollTrList)
self.TSollVxLabels = TSollLabels
self.TSoll = Triangulation(self.TSollVx[:, 0], self.TSollVx[:, 1],
self.TSollTr)
# Segmenti di sollevamento associati ai lati di bordo.
# ESollPos[i,j] memorizza la posizione di S^e_{ij} in ESollVx.
self.ESollPos = {}
for edge in self.domain.splitPoints:
# se il lato edge sta nel bordo si ricavano i punti S^e_ij e Q_{ij}^e
if self.domain.splitPoints[edge][1]:
for i in range(2):
# punti S^e_{ij}
ESollVxList.append(
2 / 3 * self.domain.startPoints[edge[i]] +
1 / 3 * self.domain.splitPoints[edge][0])
ESollLabels.append('$S^e_{' + str(edge[i] + 1) + ',' +
str(edge[(i + 1) % 2] + 1) + '}$')
# aggiorno ESollPos
self.ESollPos[edge[i],
edge[(i + 1) % 2]] = len(ESollVxList) - 1
# coefficienti sigma^e_{ij}
self.ESollSigma[edge[i],
edge[(i + 1) % 2]] = self.domain.lamb[edge[
(i + 1) % 2], edge[i]] / 2
# punti Q^e_{ij}
ESollVxList.append(
ESollVxList[-1] +
2 / 3 * self.ESollSigma[edge[i], edge[(i + 1) % 2]] *
(self.domain.startPoints[edge[
(i + 1) % 2]] - self.domain.startPoints[edge[i]]))
ESollLabels.append('$Q^e_{' + str(edge[i] + 1) + ',' +
str(edge[(i + 1) % 2] + 1) + '}$')
# Salvo vertici ed etichette dei segmenti di sollevamento al bordo.
self.ESollVxLabels = ESollLabels
self.ESollVx = np.array(ESollVxList)
def scatter_xyc(points, smooth=0, div=10, ax=None, **options):
"""
Draws a 2D graph (X,Y, color), the color is chosen based on a value *f(x,y)*
The function requires :epkg:`matploblib` and :epkg:`scipy`.
@param points (x,y, z=f(x,y) )
@param smooth applies n times a smoothing I * M (convolutional)
@param div number of divisions for axis
@param options others options: xlabel, ylabel, title, figsize (if ax is None)
@return fig, ax (fig is None if ax was sent to the function)
.. plot::
:include-source:
import random
def generate_gauss(x, y, sigma, N=1000):
res = []
for i in range(N):
u = random.gauss(0, 1)
a = sigma * u + x
b = sigma * random.gauss(0, 1) + y + u
res.append((a, b))
return res
def f(a, b):
return (a ** 2 + b ** 2) ** 0.5
nuage1 = generate_gauss(0, 0, 3)
nuage2 = generate_gauss(3, 4, 2)
nuage = [(a, b, f(a, b)) for a, b in nuage1] + [(a, b, f(a, b)) for a, b in nuage2]
import matplotlib.pyplot as plt
from ensae_teaching_cs.helpers.matplotlib_helper_xyz import scatter_xyc
fig, ax = scatter_xyc(nuage, title="example with random observations")
plt.show()
The error ``ValueError: Unknown projection '3d'`` is raised when the line
``from mpl_toolkits.mplot3d import Axes3D`` is missing.
"""
if ax is None:
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=options.get('figsize', None))
else:
fig = None
x = [_[0] for _ in points]
y = [_[1] for _ in points]
z = [_[2] for _ in points]
tri = Triangulation(x, y)
plt.tricontour(tri, z, 15, linewidths=0.5, colors='k')
plt.tricontourf(tri,
z,
15,
cmap=plt.cm.rainbow,
norm=Normalize(vmax=numpy.abs(z).max(),
vmin=-numpy.abs(z).max()))
plt.colorbar(ax=ax)
ax.scatter(x, y, c='b', s=5, zorder=10)
ax.set_xlim(min(x), max(x))
ax.set_ylim(min(y), max(y))
if "xlabel" in options:
ax.set_xlabel(options["xlabel"])
if "ylabel" in options:
ax.set_ylabel(options["ylabel"])
if "title" in options:
ax.set_title(options["title"])
return fig, ax
def visualization(self, savename='figure'):
# --> Sets figure.
fig = plt.figure()
# Mesh arrays.
x = self.x[:self.nde]
y = self.y[:self.nde]
# Vorticity array.
vorticity = self.vorticity[:self.nde]
# Delaunay triangulation.
tri = Triangulation(x, y)
# Mask unwanted triangles.
radius = 0.5
xmid = tri.x[tri.triangles].mean(axis=1)
ymid = tri.y[tri.triangles].mean(axis=1)
xc1, yc1 = 0, 0.75
xc2, yc2 = 0, -0.75
xc3, yc3 = -1.5 * np.sqrt(0.75), 0
mask = np.where((xmid - xc1)**2 + (ymid - yc1)**2 < radius**2, 1, 0)
mask += np.where((xmid - xc2)**2 + (ymid - yc2)**2 < radius**2, 1, 0)
mask += np.where((xmid - xc3)**2 + (ymid - yc3)**2 < radius**2, 1, 0)
tri.set_mask(mask)
# Plot the vorticity field.
ax = fig.gca()
cmap = plt.cm.RdBu
h = ax.tripcolor(tri, vorticity, shading='gouraud', cmap=cmap)
h.set_clim(-4, 4)
ax.set_aspect('equal')
ax.set_xlim(-5, 20)
ax.set_ylim(-4, 4)
# Set up the colorbar.
divider = make_axes_locatable(ax)
cax = divider.append_axes('right', size='5%', pad=0.1)
cb = plt.colorbar(h, cax=cax)
tick_locator = ticker.MaxNLocator(nbins=5)
cb.locator = tick_locator
cb.update_ticks()
# Highlight the cylinders.
xc, yc, r = 0., 0.75, 0.5
circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
ax.add_patch(circle)
xc, yc, r = 0., -0.75, 0.5
circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
ax.add_patch(circle)
xc, yc, r = -1.5 * np.sqrt(0.75), 0., 0.5
circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
ax.add_patch(circle)
# Titles, labels, ...
ax.set_xlabel(r'$x$')
ax.locator_params(axis='y', nbins=5)
ax.set_ylabel(r'$y$', rotation=0)
# Save the figure.
fig.savefig(savename + '.png', bbox_inches='tight', dpi=300)
return fig, ax
def plottest(choice):
t = np.loadtxt('./infiles/t.txt')
p = np.loadtxt('./infiles/p.txt')
sol = np.loadtxt('./files/sol.dat')
solx = np.loadtxt('./files/solx.dat')
soly = np.loadtxt('./files/soly.dat')
diffx = np.loadtxt('./files/diffx.dat')
diffy = np.loadtxt('./files/diffy.dat')
ratx = np.loadtxt('./files/ratx.dat')
raty = np.loadtxt('./files/raty.dat')
ex = np.loadtxt('./files/ex.dat')
ey = np.loadtxt('./files/ey.dat')
exa = np.loadtxt('./files/exact.dat')
boundx = np.loadtxt('./files/boundx.dat')
boundy = np.loadtxt('./files/boundy.dat')
exbx = np.loadtxt('./files/exbx.dat')
exby = np.loadtxt('./files/exby.dat')
tr = Triangulation(p[:, 0], p[:, 1], triangles=t - 1)
if choice == 's':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, sol, cmap=plt.cm.CMRmap)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'exact':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, exa)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'sx':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, solx)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'sy':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, soly)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'dx':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, diffx)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'dy':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, diffy)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'rx':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, ratx)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'ry':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, raty)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'ex':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, ex)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'ey':
ax = Axes3D(plt.gcf())
ax.plot_trisurf(tr, ey)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
elif choice == 'boundx':
x = boundx[:, 1]
y = boundx[:, 0]
plt.scatter(x, y, color='red')
plt.show()
elif choice == 'boundy':
x = boundy[:, 1]
y = boundy[:, 0]
plt.scatter(x, y, color='red')
plt.show()
elif choice == 'exbx':
x = exbx[:, 1]
y = exbx[:, 0]
plt.scatter(x, y)
plt.show()
elif choice == 'exby':
x = exby[:, 1]
y = exby[:, 0]
plt.scatter(x, y)
plt.show()
def slice_to_array(self, slc, offset: float = 0.0, name: str = "Y"):
"""Converts a PolyData slice to a 2D NumPy array.
It is crucial to have the true normal and origin of
the slicing plane
Parameters
----------
slc : PolyData
Slice as slice through a mesh.
"""
# Get slice
if self.debug:
print(" Getting Slice")
slctemp = slc.copy(deep=True)
slctemp.points = (self.rotmat.T @ slctemp.points.T).T
# Interpolate slices
if self.debug:
print(" Creating polydata")
# Depending on the slice, column 1 or 2 will contain the points
if offset == 0.0:
points = np.vstack((slctemp.points[:, 0], slctemp.points[:, 2],
np.zeros_like(slctemp.points[:, 2]))).T
else:
points = np.vstack((slctemp.points[:, 0], slctemp.points[:, 1],
np.zeros_like(slctemp.points[:, 1]))).T
pc = pv.PolyData(points)
if self.debug:
print(" Triangulate")
mesh = pc.delaunay_2d(alpha=0.5 * 1.5 * lpy.DEG2KM)
mesh[self.meshname] = slctemp[self.meshname]
# Get triangles from delauney triangulation to be
# used for interpolation
if self.debug:
print(" Reshape Triangles")
xy = np.array(mesh.points[:, 0:2])
r, t = lpy.math.cart2pol(xy[:, 0], xy[:, 1])
findlimt = t + 4 * np.pi
mint = np.min(findlimt) - 4 * np.pi
maxt = np.max(findlimt) - 4 * np.pi
cells = mesh.faces.reshape(mesh.n_cells, 4)
triangles = np.array(cells[:, 1:4])
# Set maximum slice length (makes no sense otherwise)
if mint < -11.25:
mint = -11.25
if maxt > 11.25:
maxt = 11.25
# Set up intterpolation values
dmin = np.min(lpy.base.EARTH_RADIUS_KM - r)
dmax = np.max(lpy.base.EARTH_RADIUS_KM - r)
dsamp = np.linspace(dmin, dmax, 1000)
tsamp = np.linspace(mint, maxt, 1000)
tt, dd = np.meshgrid(tsamp, dsamp)
# you can add keyword triangles here if you have the triangle array,
# size [Ntri,3]
if self.debug:
print(" Triangulation 2")
triObj = Triangulation(t, r, triangles=triangles)
# linear interpolation
fz = LinearTriInterpolator(triObj, mesh[self.meshname])
Z = fz(tt, lpy.base.EARTH_RADIUS_KM - dd)
# Get aspect of the figure
aspect = ((maxt - mint) * 180 / np.pi * lpy.DEG2KM) / (dmax - dmin)
height = 4.0
width = height * aspect
if self.debug:
print(" Plotting")
# Create figure
plt.figure(figsize=(width, height))
plt.imshow(Z,
extent=[
mint * 180 / np.pi * lpy.DEG2KM,
maxt * 180 / np.pi * lpy.DEG2KM, dmax, dmin
],
cmap=self.cmapname,
vmin=self.clim[0],
vmax=self.clim[1],
rasterized=True)
from_north = np.abs(self.rotangle * 180 / np.pi) + offset
plt.title(rf"$N{from_north:6.2f}^\circ \rightarrow$")
plt.xlabel('Offset [km]')
plt.ylabel('Depth [km]')
if not self.figures_only:
plt.show(block=False)
plt.savefig(
os.path.join(
self.outputdir, f"slice_{name}_"
f"lat{int(self.latitude+90.0)}_"
f"lon{int(self.longitude+180.0)}_"
f"N{int(from_north)}_{self.meshname}.pdf"))
"""
def multiview(data, suptitle='', figsize=(15, 10), **kwds):
cs = cortex
vtx = cs.vertices
tri = cs.triangles
rm = cs.region_mapping
x, y, z = vtx.T
lh_tri = tri[(rm[tri] < 38).any(axis=1)]
lh_vtx = vtx[rm < 38]
lh_x, lh_y, lh_z = lh_vtx.T
lh_tx, lh_ty, lh_tz = lh_vtx[lh_tri].mean(axis=1).T
rh_tri = tri[(rm[tri] >= 38).any(axis=1)]
rh_vtx = vtx[rm < 38]
rh_x, rh_y, rh_z = rh_vtx.T
rh_tx, rh_ty, rh_tz = vtx[rh_tri].mean(axis=1).T
tx, ty, tz = vtx[tri].mean(axis=1).T
views = {
'lh-lateral': Triangulation(-x, z, lh_tri[argsort(lh_ty)[::-1]]),
'lh-medial': Triangulation(x, z, lh_tri[argsort(lh_ty)]),
'rh-medial': Triangulation(-x, z, rh_tri[argsort(rh_ty)[::-1]]),
'rh-lateral': Triangulation(x, z, rh_tri[argsort(rh_ty)]),
'both-superior': Triangulation(y, x, tri[argsort(tz)]),
}
def plotview(i,
j,
k,
viewkey,
z=None,
zlim=None,
zthresh=None,
suptitle='',
shaded=True,
cmap=plt.cm.coolwarm,
viewlabel=False):
v = views[viewkey]
ax = subplot(i, j, k)
if z is None:
z = rand(v.x.shape[0])
if not viewlabel:
axis('off')
kwargs = {
'shading': 'gouraud'
} if shaded else {
'edgecolors': 'k',
'linewidth': 0.1
}
if zthresh:
z = z.copy() * (abs(z) > zthresh)
tc = ax.tripcolor(v, z, cmap=cmap, **kwargs)
if zlim:
tc.set_clim(vmin=-zlim, vmax=zlim)
ax.set_aspect('equal')
if suptitle:
ax.set_title(suptitle, fontsize=24)
if viewlabel:
xlabel(viewkey)
figure(figsize=figsize)
plotview(2, 3, 1, 'lh-lateral', data, **kwds)
plotview(2, 3, 4, 'lh-medial', data, **kwds)
plotview(2, 3, 3, 'rh-lateral', data, **kwds)
plotview(2, 3, 6, 'rh-medial', data, **kwds)
plotview(1, 3, 2, 'both-superior', data, suptitle=suptitle, **kwds)
subplots_adjust(left=0.0,
right=1.0,
bottom=0.0,
top=1.0,
wspace=0,
hspace=0)
update_polygon(tri)
plt.title('In triangle %i' % tri)
event.canvas.draw()
# Create a Triangulation.
n_angles = 16
n_radii = 5
min_radius = 0.25
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += math.pi / n_angles
x = (radii * np.cos(angles)).flatten()
y = (radii * np.sin(angles)).flatten()
triangulation = Triangulation(x, y)
xmid = x[triangulation.triangles].mean(axis=1)
ymid = y[triangulation.triangles].mean(axis=1)
mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
triangulation.set_mask(mask)
# Use the triangulation's default TriFinder object.
trifinder = triangulation.get_trifinder()
# Setup plot and callbacks.
plt.subplot(111, aspect='equal')
plt.triplot(triangulation, 'bo-')
polygon = Polygon([[0, 0], [0, 0]], facecolor='y') # dummy data for xs,ys
update_polygon(-1)
plt.gca().add_patch(polygon)
plt.gcf().canvas.mpl_connect('motion_notify_event', motion_notify)
def triangulation(self):
if len(self.tria3) > 0:
return Triangulation(self.x, self.y, self.tria3)
def subdivideMesh(IKLE,MESHX,MESHY):
"""
Requires the matplotlib.tri package to be loaded.
- Will use already computed edges or re-create it if necessary.
This function return a new tuple IKLE,MESHX,MESHY where each triangle has been
subdivided in 4.
"""
# ~~> Singling out edges
from matplotlib.tri import Triangulation
edges = Triangulation(MESHX,MESHY,IKLE).get_cpp_triangulation().get_edges()
# ~~> Memory allocation for new MESH
IELEM = len(IKLE); IPOIN = len(MESHX); IEDGE = len(edges)
JKLE = np.zeros((IELEM*4,3),dtype=np.int) # you subdivide every elements by 4
MESHJ = np.zeros((IEDGE,2),dtype=np.int) # you add one point on every edges
# ~~> Lookup tables for node numbering on common edges
pa,pb = edges.T
k1b,k1a = np.sort(np.take(IKLE,[0,1],axis=1)).T
indx1 = np.searchsorted(pa,k1a)
jndx1 = np.searchsorted(pa,k1a,side='right')
k2b,k2a = np.sort(np.take(IKLE,[1,2],axis=1)).T
indx2 = np.searchsorted(pa,k2a)
jndx2 = np.searchsorted(pa,k2a,side='right')
k3b,k3a = np.sort(np.take(IKLE,[2,0],axis=1)).T
indx3 = np.searchsorted(pa,k3a)
jndx3 = np.searchsorted(pa,k3a,side='right')
# ~~> Building one triangle at a time /!\ Please get this loop parallelised
j = 0
for i in range(IELEM):
k1 = indx1[i]+np.searchsorted(pb[indx1[i]:jndx1[i]],k1b[i])
k2 = indx2[i]+np.searchsorted(pb[indx2[i]:jndx2[i]],k2b[i])
k3 = indx3[i]+np.searchsorted(pb[indx3[i]:jndx3[i]],k3b[i])
# ~~> New connectivity JKLE
JKLE[j] = [IKLE[i][0],IPOIN+k1,IPOIN+k3]
JKLE[j+1] = [IKLE[i][1],IPOIN+k2,IPOIN+k1]
JKLE[j+2] = [IKLE[i][2],IPOIN+k3,IPOIN+k2]
JKLE[j+3] = [IPOIN+k1,IPOIN+k2,IPOIN+k3]
# ~~> New interpolation references for values and coordinates
MESHJ[k1] = [IKLE[i][0],IKLE[i][1]]
MESHJ[k2] = [IKLE[i][1],IKLE[i][2]]
MESHJ[k3] = [IKLE[i][2],IKLE[i][0]]
j += 4
# ~~> Reset IPOBO while you are at it
MESHX = np.resize(MESHX,IPOIN+IEDGE)
MESHY = np.resize(MESHY,IPOIN+IEDGE)
MESHX[IPOIN:] = np.sum(MESHX[MESHJ],axis=1)/2.
MESHY[IPOIN:] = np.sum(MESHY[MESHJ],axis=1)/2.
neighbours = Triangulation(MESHX,MESHY,JKLE).get_cpp_triangulation().get_neighbors()
JPOBO = np.zeros(IPOIN+IEDGE,np.int)
for n in range(IELEM*4):
s1,s2,s3 = neighbours[n]
e1,e2,e3 = JKLE[n]
if s1 < 0:
JPOBO[e1] = e1+1
JPOBO[e2] = e2+1
if s2 < 0:
JPOBO[e2] = e2+1
JPOBO[e3] = e3+1
if s3 < 0:
JPOBO[e3] = e3+1
JPOBO[e1] = e1+1
return JKLE,MESHX,MESHY,JPOBO,MESHJ
n_angles = 30
n_radii = 10
min_radius = 0.2
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += np.pi / n_angles
x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
V = dipole_potential(x, y)
# Create the Triangulation; no triangles specified so Delaunay triangulation
# created.
triang = Triangulation(x, y)
# Mask off unwanted triangles.
triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
y[triang.triangles].mean(axis=1))
< min_radius)
#-----------------------------------------------------------------------------
# Refine data - interpolates the electrical potential V
#-----------------------------------------------------------------------------
refiner = UniformTriRefiner(triang)
tri_refi, z_test_refi = refiner.refine_field(V, subdiv=3)
#-----------------------------------------------------------------------------
# Computes the electrical field (Ex, Ey) as gradient of electrical potential
#-----------------------------------------------------------------------------
def sliceMesh(polyline,IKLE,MESHX,MESHY,tree=None):
"""
A new method to slice through a triangular mesh (replaces crossMesh)
"""
from matplotlib.tri import Triangulation
xys = []
douplets = []
# ~~> Calculate the minimum mesh resolution
dxy = math.sqrt(min(np.square(np.sum(np.fabs(MESHX[IKLE]-MESHX[np.roll(IKLE,1)]),axis=1)/3.0) + \
np.square(np.sum(np.fabs(MESHY[IKLE]-MESHY[np.roll(IKLE,1)]),axis=1)/3.0)))
accuracy = np.power(10.0, -8+np.floor(np.log10(dxy)))
xyo = np.array(polyline[0])
for i in range(len(polyline)-1):
xyi = np.array(polyline[i+1])
dio = math.sqrt(sum(np.square(xyo-xyi)))
# ~~> Resample the line to that minimum mesh resolution
rsmpline = np.dstack((np.linspace(xyo[0],xyi[0],num=int(dio/dxy)),np.linspace(xyo[1],xyi[1],num=int(dio/dxy))))[0]
nbpoints = len(rsmpline)
nbneighs = min( 8,len(IKLE) )
# ~~> Filter closest 8 elements (please create a good mesh) as a halo around the polyline
halo = np.zeros((nbpoints,nbneighs),dtype=np.int)
for i in range(nbpoints):
d,e = tree.query(rsmpline[i],nbneighs)
halo[i] = e
halo = np.unique(halo)
# ~~> Get the intersecting halo (on a smaller mesh connectivity)
edges = Triangulation(MESHX,MESHY,IKLE[halo]).get_cpp_triangulation().get_edges()
# ~~> Last filter, all nodes that are on the polyline
olah = []
nodes = np.unique(edges)
for node in nodes: # TODO(jcp): replace by numpy calcs
if getDistancePointToLine((MESHX[node],MESHY[node]),xyo,xyi) < accuracy: olah.append(node)
ijsect = zip(olah,olah)
xysect = [(MESHX[i],MESHY[i]) for i in olah]
lmsect = [ (1.0,0.0) for i in range(len(ijsect)) ]
mask = np.zeros((len(edges),2),dtype=bool)
for i in olah:
mask = np.logical_or( edges == i , mask )
edges = np.compress(np.logical_not(np.any(mask,axis=1)),edges,axis=0)
# ~~> Intersection with remaining edges
for edge in edges:
xyj = getSegmentIntersection( (MESHX[edge[0]],MESHY[edge[0]]),(MESHX[edge[1]],MESHY[edge[1]]),xyo,xyi )
if xyj != []:
ijsect.append(edge) # nodes from the mesh
xysect.append(tuple(xyj[0])) # intersection (xo,yo)
lmsect.append((xyj[1],1.0-xyj[1])) # weight along each each
# ~~> Final sorting along keys x and y
xysect = np.array(xysect, dtype=[('x', '<f4'), ('y', '<f4')])
xysort = np.argsort(xysect, order=('x','y'))
# ~~> Move on to next point
for i in xysort:
xys.append( xysect[i] )
douplets.append( (ijsect[i],lmsect[i]) )
xyo = xyi
return xys,douplets
def reload(self, imageName, seed, scale):
try:
#Let's create a canvas
#voronoiCircles = []
self.w.pack()
self.w.delete("all")
#Let's create an image
image = Image.open(imageName)
colors = []
pixels = image.load()
width, height = image.size
#print(width)
#Just a testing data structure. Don't use this.
all_pixels = []
#Use this one when doing calculations.
points = []
xarray = []
yarray = []
color = ["red", "orange", "yellow", "green", "blue", "violet"]
#loop(self, points, pixels, all_pixels, width, height)
for x in range(width):
for y in range(height):
cpixel = pixels[x, y]
#colors.append(cpixel)
#print(cpixel)
foo = random.randint(1, seed)
#if (round(sum(cpixel)) / float(len(cpixel)) > 127) & (x%foo == 0) & (y%foo == 0):
if ( x%foo == 0) and (y%foo == 0):
all_pixels.append(255)
points.append(Point(x*scale, y*scale))
xarray.append(x*scale)
yarray.append(y*scale)
colors.append(cpixel)
#self.w.create_oval(x*2, y*2, x*2+1, y*2+1, fill="black")
#else:
# all_pixels.append(0) #print(all_pixels)
triangulation = Triangulation(xarray, yarray)
triangles = triangulation.get_masked_triangles()
#triangles = triangulation.triangles()
#print(triangles)
for triangle in triangles:
x1 = xarray[triangle[0]]
y1 = yarray[triangle[0]]
x2 = xarray[triangle[1]]
y2 = yarray[triangle[1]]
x3 = xarray[triangle[2]]
y3 = yarray[triangle[2]]
#print(circumcircle(circle))
#red= colors[triangle[0]][0]
try:
red=colors[triangle[0]][0]
green= colors[triangle[0]][1]
blue= colors[triangle[0]][2]
mycolor = '#%02x%02x%02x' % (red, green, blue)
except IndexError:
if colors[triangle[0]][1] > 100:
mycolor='black'
else:
mycolor='white'
self.w.create_polygon([x1, y1], [x2, y2], [x3, y3], fill=mycolor)
center = circumcenter([x1, y1], [x2, y2], [x3, y3])
bisector1 = [[(x1+x2)/2], [(y1+y2)/2]]
bisector2 = [[(x2+x3)/2], [(y2+y3)/2]]
bisector3 = [[(x3+x1)/2], [(y3+y1)/2]]
self.w.create_line(center[0], center[1], bisector1[0], bisector1[1])
self.w.create_line(center[0], center[1], bisector2[0], bisector2[1])
self.w.create_line(center[0], center[1], bisector3[0], bisector3[1])
#self.w.create_oval(center[0]-1, center[1]-1, center[0]+1, center[1]+1, fill="black")
#create_circle(self.w, center[0], center[1], center[2])
#voronoiCircles.append(center)
except (AttributeError, IOError, FileNotFoundError):
pass
"""
def hitlist2int_list(x, y):
"""Function that estimates an intensity distribution on a plane from a
ray hitlist. Returns the intensity samples as an x,y,I list
"""
from pylab import meshgrid
from scipy import interpolate
from scipy.interpolate import griddata
#if xi.ndim != yi.ndim:
# raise TypeError("inputs xi and yi must have same number of dimensions (1 or 2)")
#if xi.ndim != 1 and xi.ndim != 2:
# raise TypeError("inputs xi and yi must be 1D or 2D.")
#if not len(x)==len(y)==len(z):
# raise TypeError("inputs x,y,z must all be 1D arrays of the same length")
# remove masked points.
#if hasattr(z,'mask'):
# x = x.compress(z.mask == False)
# y = y.compress(z.mask == False)
# z = z.compressed()
#if xi.ndim == 1:
# xi,yi = meshgrid(xi,yi)
#triangulate data
tri = Triangulation(x, y)
#calculate triangles area
#ntriangles=tri.circumcenters.shape[0]
coord = array(zip(tri.x, tri.y))
#I=zeros((ntriangles, ))
#xc=zeros((ntriangles, ))
#yc=zeros((ntriangles, ))
# for i in range(ntriangles):
# i1, i2, i3=tri.triangle_nodes[i]
# p1=coord[i1]
# p2=coord[i2]
# p3=coord[i3]
# v1=p1-p2
# v2=p3-p2
# I[i]=1./(abs(v1[0]*v2[1]-v1[1]*v2[0]))
# # the circumcenter data from the triangulation, has some problems so we
# # recalculate it
# xc[i], yc[i]=(p1+p2+p3)/3.
# The previous code was replaced by the following code
###
i1 = tri.triangles[:, 0]
i2 = tri.triangles[:, 1]
i3 = tri.triangles[:, 2]
p1 = coord[i1]
p2 = coord[i2]
p3 = coord[i3]
v1 = p1 - p2
v2 = p3 - p2
I = abs(1. / (v1[:, 0] * v2[:, 1] - v1[:, 1] * v2[:, 0]))
c = (p1 + p2 + p3) / 3.
xc = c[:, 0]
yc = c[:, 1]
###
# Because of the triangulation algorithm, there are some really high values
# in the intensity data. To filter these values, remove the 5% points of the
# higher intensity.
ni = int(0.1 * len(I))
j = I.argsort()[:-ni]
xc = xc[j]
yc = yc[j]
I = I[j]
I = I / I.max()
# #print tri.circumcenters[:, 0]
# #print tri.circumcenters.shape
# print ntriangles, tri.circumcenters[:, 0].shape, tri.circumcenters[:, 0].flatten().shape
#itri=delaunay.Triangulation(xc,yc)
#inti=itri.linear_interpolator(I)
#xi,yi = meshgrid(xi,yi)
#d1=itri(xi, yi)
#Interpolacion con Splines
#di=interpolate.SmoothBivariateSpline(xc, yc, I)
#d1=di(xi,yi)
return xc, yc, I
