def test_mesh(self):
p1 = Vertex(*[0, 0, 0])
p2 = Vertex(*[1, 0, 0])
p3 = Vertex(*[0, 1, 0])
p4 = Vertex(*[1, 1, 0])
p5 = Vertex(*[0, 0, 0])
a = Polygon([p1, p2, p3, p4])
b = Polygon([p1, p2, p4, p5])
m1 = Mesh({"a": [a]}, boundary_nodes={"j": list(a)})
m2 = Mesh({"b": [b]}, boundary_nodes={"j": list(b)})
m3 = m1 + m2
m3.delete_duplicates()
for vertex in a:
self.assertTrue(vertex in m3.vertices)
def get_mesh_panels(self, num_midribs=0):
mesh = Mesh(name="panels")
for cell in self.cells:
for panel in cell.panels:
mesh += panel.get_mesh(cell, num_midribs)
return mesh
def get_mesh_hull(self, num_midribs=0, ballooning=True):
ribs = self.return_ribs(num=num_midribs, ballooning=ballooning)
num = len(ribs)
numpoints = len(ribs[0]) # points per rib
polygons = []
boundary = {
"ribs": [],
"trailing_edge": []
}
for i in range(num-1): # because we use i+1 below
boundary["trailing_edge"].append(i*numpoints)
if not i % (num_midribs+1):
boundary["ribs"] += [i*numpoints+k for k in range(numpoints-1)]
for k in range(numpoints - 1): # same reason as above
kplus = (k+1) % (numpoints-1)
polygons.append([
i * numpoints + k,
i * numpoints + kplus,
(i + 1) * numpoints + kplus,
(i + 1) * numpoints + k
])
return Mesh.from_indexed(np.concatenate(ribs), {"hull": polygons}, boundary)
def get_upper_line_mesh(self, numpoints=1, breaks=False):
mesh = Mesh()
for line in self.uppermost_lines:
if not breaks:
# TODO: is there a better solution???
if "BR" in line.upper_node.name:
continue
mesh += line.get_mesh(numpoints)
return mesh
def get_mesh(self, cell):
boundaries = {}
rib1 = cell.rib1
rib2 = cell.rib2
p1 = rib1.profile_3d[rib1.profile_2d(self.left)]
p2 = rib2.profile_3d[rib2.profile_2d(self.right)]
boundaries[rib1.name] = [0]
boundaries[rib2.name] = [1]
return Mesh.from_indexed([p1, p2], {"tension_lines": [[0, 1]]}, boundaries=boundaries)
def get_mesh(self, numpoints):
line_points = [Vertex(*point) for point in self.get_line_points(numpoints=numpoints)]
boundary = {"lines": []}
if self.lower_node.type == 0:
boundary["lower_attachment_points"] = [line_points[0]]
else:
boundary["lines"].append(line_points[0])
if self.upper_node.type == 2:
boundary["attachment_points"] = [line_points[-1]]
else:
boundary["lines"].append(line_points[-1])
line_poly = {"lines": [Polygon(line_points[i:i + 2]) for i in range(len(line_points) - 1)]}
return Mesh(line_poly, boundary)
def test_glider_mesh(self):
dist = Distribution.from_nose_cos_distribution(30, 0.2)
dist.add_glider_fixed_nodes(self.glider)
self.glider.profile_x_values = dist
m = Mesh(name="glider_mesh")
for cell in self.glider.cells[1:-1]:
m += cell.get_mesh(0)
for rib in self.glider.ribs:
m += Mesh.from_rib(rib)
m.delete_duplicates()
m.get_indexed()
def get_mesh(self, midribs=0):
mesh = Mesh()
for rib in self.ribs:
if not rib.profile_2d.has_zero_thickness:
mesh += rib.get_mesh(filled=True, glider=self)
for cell in self.cells:
for diagonal in cell.diagonals:
mesh += diagonal.get_mesh(cell)
mesh += self.lineset.get_mesh()
mesh += self.get_mesh_panels(num_midribs=midribs)
mesh += self.get_mesh_hull(midribs)
return mesh
def get_mesh_mapping(self,
cell_number=0,
numribs=0,
with_numpy=False,
half_cell=False):
"""
Get Cell-mesh
:cell_number: number of cell
:param numribs: number of miniribs to calculate
:return: mesh
"""
numribs += 1
ribs = []
rib_indices = range(numribs + 1)
if half_cell:
rib_indices = rib_indices[(numribs) // 2:]
for rib_no in rib_indices:
y = rib_no / max(numribs, 1)
rib = (self.rib1.profile_2d.get_data(negative_x=True) * (1 - y) +
self.rib2.profile_2d.get_data(negative_x=True) * y)
y += cell_number
rib = np.array([rib.T[0],
np.array([y] * len(rib)),
rib.T[1]]).T # insert y-value
ribs.append(Vertex.from_vertices_list(rib))
quads = []
for rib_left, rib_right in zip(ribs[:-1], ribs[1:]):
numpoints = len(rib_left)
for i in range(numpoints - 1):
i_next = i + 1
pol = Polygon([
rib_left[i], rib_right[i], rib_right[i_next],
rib_left[i_next]
])
quads.append(pol)
mesh = Mesh({"hull": quads}, {
self.rib1.name: ribs[0],
self.rib2.name: ribs[-1]
})
return mesh
def get_mesh(self, numribs=0, with_numpy=False, half_cell=False):
"""
Get Cell-mesh
:param numribs: number of miniribs to calculate
:return: mesh
"""
numribs += 1
ribs = []
trailing_edge = []
rib_indices = range(numribs + 1)
if half_cell:
rib_indices = rib_indices[(numribs) // 2:]
for rib_no in rib_indices:
y = rib_no / max(numribs, 1)
rib = self.midrib(y, with_numpy=with_numpy).data
ribs.append(Vertex.from_vertices_list(rib[:-1]))
quads = []
for rib_left, rib_right in zip(ribs[:-1], ribs[1:]):
numpoints = len(rib_left)
for i in range(numpoints):
i_next = (i + 1) % numpoints
pol = Polygon([
rib_left[i], rib_right[i], rib_right[i_next],
rib_left[i_next]
])
pol.influenceFlow = True
quads.append(pol)
for rib in ribs:
trailing_edge.append(rib[0])
mesh = Mesh({"hull": quads}, {
self.rib1.name: ribs[0],
self.rib2.name: ribs[-1],
"trailing_edge": trailing_edge
})
return mesh
def get_mesh(self, numpoints=10):
return sum([line.get_mesh(numpoints) for line in self.lines], Mesh())
def get_mesh(self, cell, numribs=0, with_numpy=False):
"""
Get Panel-mesh
:param cell: the parent cell of the panel
:param numribs: number of interpolation steps between ribs
:param with_numpy: compute midribs with numpy (faster if available)
:return: mesh objects consisting of triangles and quadrangles
"""
numribs += 1
# TODO: doesnt work for numribs=0?
xvalues = cell.rib1.profile_2d.x_values
ribs = []
points = []
nums = []
count = 0
for rib_no in range(numribs + 1):
y = rib_no / max(numribs, 1)
x1 = self.cut_front["left"] + y * (self.cut_front["right"] -
self.cut_front["left"])
front = get_x_value(xvalues, x1)
x2 = self.cut_back["left"] + y * (self.cut_back["right"] -
self.cut_back["left"])
back = get_x_value(xvalues, x2)
midrib = cell.midrib(y, with_numpy=with_numpy)
ribs.append([x for x in midrib.get_positions(front, back)])
points += list(midrib[front:back])
nums.append([i + count for i, _ in enumerate(ribs[-1])])
count += len(ribs[-1])
triangles = []
# helper functions
def left_triangle(l_i, r_i):
return [l_i + 1, l_i, r_i]
def right_triangle(l_i, r_i):
return [r_i + 1, l_i, r_i]
def quad(l_i, r_i):
return [l_i + 1, l_i, r_i, r_i + 1]
for rib_no, _ in enumerate(ribs[:-1]):
num_l = nums[rib_no]
num_r = nums[rib_no + 1]
pos_l = ribs[rib_no]
pos_r = ribs[rib_no + 1]
l_i = r_i = 0
while l_i < len(num_l)-1 or r_i < len(num_r)-1:
if l_i == len(num_l) - 1:
triangles.append(right_triangle(num_l[l_i], num_r[r_i]))
r_i += 1
elif r_i == len(num_r) - 1:
triangles.append(left_triangle(num_l[l_i], num_r[r_i]))
l_i += 1
elif abs(pos_l[l_i] - pos_r[r_i]) == 0:
triangles.append(quad(num_l[l_i], num_r[r_i]))
r_i += 1
l_i += 1
elif pos_l[l_i] <= pos_r[r_i]:
triangles.append(left_triangle(num_l[l_i], num_r[r_i]))
l_i += 1
elif pos_r[r_i] < pos_l[l_i]:
triangles.append(right_triangle(num_l[l_i], num_r[r_i]))
r_i += 1
#connection_info = {cell.rib1: np.array(ribs[0], int),
# cell.rib2: np.array(ribs[-1], int)}
return Mesh.from_indexed(points, {"panel_"+self.material_code: triangles}, name=self.name)
def get_mesh(self, cell, insert_points=4, project_3d=False):
"""
get a mesh from a diagonal (2 poly lines)
"""
left, right = self.get_3d(cell)
if insert_points:
point_array = []
points2d = []
number_array = []
# create array of points
# the outermost points build the segments
num_left = len(left)
num_right = len(right)
count = 0
for y_pos in np.linspace(0., 1., insert_points + 2):
# from left to right
line_points = []
line_points_2d = [] # TODO: mesh 2d (x, y) -> 3d nodes
line_indices = []
num_points = int(num_left * (1. - y_pos) + num_right * y_pos)
for x_pos in np.linspace(0., 1., num_points):
line_points.append(left[x_pos * (num_left - 1)] * (1. - y_pos) +
right[x_pos * (num_right - 1)] * y_pos)
line_points_2d.append([x_pos, y_pos])
line_indices.append(count)
count += 1
point_array += line_points
points2d += line_points_2d
number_array.append(line_indices)
# outline
edge = number_array[0]
edge += [line[-1] for line in number_array[1:]]
edge += number_array[-1][-2::-1] # last line reversed without the last element
edge += [line[0] for line in number_array[1:-1]][::-1]
segment = [[edge[i], edge[i +1]] for i in range(len(edge) - 1)]
segment.append([edge[-1], edge[0]])
point_array = np.array(point_array)
import openglider.mesh.mesh as _mesh
if project_3d:
points2d = _mesh.map_to_2d(point_array)
tri = triangulate.Triangulation(points2d, [edge])
mesh = tri.triangulate(options="Qz")
# mesh_info = _mesh.mptriangle.MeshInfo()
# mesh_info.set_points(points2d)
# mesh_info.set_facets(segment)
# mesh = _mesh.custom_triangulation(mesh_info, "Qz")
return Mesh.from_indexed(point_array, {"diagonals": list(mesh.elements)}, boundaries={"diagonals": edge})
else:
vertices = np.array(list(left) + list(right)[::-1])
polygon = [range(len(vertices))]
return Mesh.from_indexed(vertices, {"diagonals": polygon})
def join(self):
mesh = Mesh()
for obj in self.objects:
mesh += obj
return mesh
def test_mesh(self):
self.rib.holes.append(RibHole(0.2))
Mesh.from_rib(self.rib)