def mesh(self) -> MeshTransformer: """Returns geometry as one :class:`MeshTransformer` object.""" faces = self.faces() mesh = MeshVertexMerger() for vertices in self: mesh.add_mesh(vertices=vertices, faces=faces) # type: ignore return MeshTransformer.from_builder(mesh)
def cone(count: int = 16, radius: float = 1.0, apex: 'Vertex' = (0, 0, 1), caps=True, ngons=True) -> MeshTransformer: """ Create a `cone <https://en.wikipedia.org/wiki/Cone>`_ as :class:`~ezdxf.render.MeshTransformer` object, the base center is fixed in the origin (0, 0, 0). Args: count: edge count of basis_vector radius: radius of basis_vector apex: tip of the cone caps: add a bottom face if ``True`` ngons: use ngons for caps if ``True`` else subdivide caps into triangles Returns: :class:`~ezdxf.render.MeshTransformer` """ mesh = MeshVertexMerger() base_circle = list(circle(count, radius, close=True)) for p1, p2 in zip(base_circle, base_circle[1:]): mesh.add_face([p1, p2, apex]) if caps: base_circle = reversed(base_circle) # for correct outside pointing normals if ngons: mesh.add_face(base_circle) else: for face in ngon_to_triangles(base_circle): mesh.add_face(face) return MeshTransformer.from_builder(mesh)
def from_profiles_linear(profiles: Iterable[Iterable['Vertex']], close: bool = True, caps: bool = False) -> MeshTransformer: """ Create MESH entity by linear connected `profiles`. Args: profiles: list of profiles close: close profile polygon if ``True`` caps: close hull with bottom cap and top cap (as N-gons) Returns: :class:`~ezdxf.render.MeshTransformer` """ mesh = MeshVertexMerger() profiles = list(profiles) # generator -> list if close: profiles = [close_polygon(p) for p in profiles] if caps: mesh.add_face(profiles[0]) mesh.add_face(profiles[-1]) for profile1, profile2 in zip(profiles, profiles[1:]): prev_v1, prev_v2 = None, None for v1, v2 in zip(profile1, profile2): if prev_v1 is not None: mesh.add_face([prev_v1, v1, v2, prev_v2]) prev_v1 = v1 prev_v2 = v2 return MeshTransformer.from_builder(mesh)
def cubes(self) -> Iterable[MeshTransformer]: """ Yields all cubes of the menger sponge as individual :class:`MeshTransformer` objects. """ faces = self.faces() for vertices in self: mesh = MeshVertexMerger() mesh.add_mesh(vertices=vertices, faces=faces) yield MeshTransformer.from_builder(mesh)
def cone_2p( count: int = 16, radius: float = 1.0, base_center=(0, 0, 0), apex=(0, 0, 1)) -> MeshTransformer: """ Create a `cone <https://en.wikipedia.org/wiki/Cone>`_ as :class:`~ezdxf.render.MeshTransformer` object from two points, `base_center` is the center of the base circle and `apex` as the tip of the cone. Args: count: edge count of basis radius: radius of basis base_center: center point of base circle apex: tip of the cone Returns: :class:`~ezdxf.render.MeshTransformer` .. versionadded:: 0.11 """ # Copyright (c) 2011 Evan Wallace (http://madebyevan.com/), under the MIT license. # Python port Copyright (c) 2012 Tim Knip (http://www.floorplanner.com), under the MIT license. # Additions by Alex Pletzer (Pennsylvania State University) # Adaptation for ezdxf, Copyright (c) 2020, Manfred Moitzi, MIT License. start = Vector(base_center) end = Vector(apex) slices = int(count) ray = end - start z_axis = ray.normalize() is_y = (fabs(z_axis.y) > 0.5) x_axis = Vector(float(is_y), float(not is_y), 0).cross(z_axis).normalize() y_axis = x_axis.cross(z_axis).normalize() mesh = MeshVertexMerger() def vertex(angle) -> Vector: # radial direction pointing out out = x_axis * cos(angle) + y_axis * sin(angle) return start + out * radius dt = pi * 2.0 / slices for i in range(0, slices): t0 = i * dt i1 = (i + 1) % slices t1 = i1 * dt # coordinates and associated normal pointing outwards of the cone's # side p0 = vertex(t0) p1 = vertex(t1) # polygon on the low side (disk sector) mesh.add_face([start, p0, p1]) # polygon extending from the low side to the tip mesh.add_face([p0, end, p1]) return MeshTransformer.from_builder(mesh)
def cylinder_2p( count: int = 16, radius: float = 1, base_center=(0, 0, 0), top_center=(0, 0, 1), ) -> MeshTransformer: """ Create a `cylinder <https://en.wikipedia.org/wiki/Cylinder>`_ as :class:`~ezdxf.render.MeshTransformer` object from two points, `base_center` is the center of the base circle and, `top_center` the center of the top circle. Args: count: profiles edge count radius: radius for bottom profile base_center: center of base circle top_center: center of top circle Returns: :class:`~ezdxf.render.MeshTransformer` .. versionadded:: 0.11 """ # Copyright (c) 2011 Evan Wallace (http://madebyevan.com/), under the MIT license. # Python port Copyright (c) 2012 Tim Knip (http://www.floorplanner.com), under the MIT license. # Additions by Alex Pletzer (Pennsylvania State University) # Adaptation for ezdxf, Copyright (c) 2020, Manfred Moitzi, MIT License. start = Vector(base_center) end = Vector(top_center) radius = float(radius) slices = int(count) ray = end - start z_axis = ray.normalize() is_y = (fabs(z_axis.y) > 0.5) x_axis = Vector(float(is_y), float(not is_y), 0).cross(z_axis).normalize() y_axis = x_axis.cross(z_axis).normalize() mesh = MeshVertexMerger() def vertex(stack, angle): out = (x_axis * cos(angle)) + (y_axis * sin(angle)) return start + (ray * stack) + (out * radius) dt = pi * 2 / float(slices) for i in range(0, slices): t0 = i * dt i1 = (i + 1) % slices t1 = i1 * dt mesh.add_face([start, vertex(0, t0), vertex(0, t1)]) mesh.add_face( [vertex(0, t1), vertex(0, t0), vertex(1, t0), vertex(1, t1)]) mesh.add_face([end, vertex(1, t1), vertex(1, t0)]) return MeshTransformer.from_builder(mesh)
def extrude( profile: Iterable["Vertex"], path: Iterable["Vertex"], close=True ) -> MeshTransformer: """Extrude a `profile` polygon along a `path` polyline, vertices of profile should be in counter clockwise order. Args: profile: sweeping profile as list of (x, y, z) tuples in counter clockwise order path: extrusion path as list of (x, y, z) tuples close: close profile polygon if ``True`` Returns: :class:`~ezdxf.render.MeshTransformer` """ def add_hull(bottom_profile, top_profile): prev_bottom = bottom_profile[0] prev_top = top_profile[0] for bottom, top in zip(bottom_profile[1:], top_profile[1:]): face = ( prev_bottom, bottom, top, prev_top, ) # counter clock wise: normals outwards mesh.faces.append(face) prev_bottom = bottom prev_top = top mesh = MeshVertexMerger() profile = Vec3.list(profile) if close: profile = close_polygon(profile) path = Vec3.list(path) start_point = path[0] # type: ignore bottom_indices = mesh.add_vertices(profile) # base profile for target_point in path[1:]: # type: ignore translation_vector = target_point - start_point # profile will just be translated profile = [vec + translation_vector for vec in profile] top_indices = mesh.add_vertices(profile) add_hull(bottom_indices, top_indices) bottom_indices = top_indices start_point = target_point return MeshTransformer.from_builder(mesh)
def from_profiles_linear(profiles: Iterable[Iterable['Vertex']], close=True, caps=False, ngons=True) -> MeshTransformer: """ Create MESH entity by linear connected `profiles`. Args: profiles: list of profiles close: close profile polygon if ``True`` caps: close hull with bottom cap and top cap ngons: use ngons for caps if ``True`` else subdivide caps into triangles Returns: :class:`~ezdxf.render.MeshTransformer` """ mesh = MeshVertexMerger() profiles = list(profiles) if close: profiles = [close_polygon(p) for p in profiles] if caps: base = reversed(profiles[0]) # for correct outside pointing normals top = profiles[-1] if ngons: mesh.add_face(base) mesh.add_face(top) else: for face in ngon_to_triangles(base): mesh.add_face(face) for face in ngon_to_triangles(top): mesh.add_face(face) for profile1, profile2 in zip(profiles, profiles[1:]): prev_v1, prev_v2 = None, None for v1, v2 in zip(profile1, profile2): if prev_v1 is not None: mesh.add_face([prev_v1, v1, v2, prev_v2]) prev_v1 = v1 prev_v2 = v2 return MeshTransformer.from_builder(mesh)
def cone(count: int = 16, radius: float = 1.0, apex: 'Vertex' = (0, 0, 1), caps: bool = True) -> MeshTransformer: """ Create a `cone <https://en.wikipedia.org/wiki/Cone>`_ as :class:`~ezdxf.render.MeshTransformer` object, the base center is fixed in the origin (0, 0, 0). Args: count: edge count of basis radius: radius of basis apex: tip of the cone caps: add a bottom face if ``True`` Returns: :class:`~ezdxf.render.MeshTransformer` """ mesh = MeshVertexMerger() base_circle = list(circle(count, radius, close=True)) for p1, p2 in zip(base_circle, base_circle[1:]): mesh.add_face([p1, p2, apex]) if caps: mesh.add_face(base_circle) return MeshTransformer.from_builder(mesh)
def sphere(count: int = 16, stacks: int = 8, radius: float = 1, quads=True) -> MeshTransformer: """ Create a `sphere <https://en.wikipedia.org/wiki/Sphere>`_ as :class:`~ezdxf.render.MeshTransformer` object, center is fixed at origin (0, 0, 0). Args: count: longitudinal slices stacks: latitude slices radius: radius of sphere quads: use quads for body faces if ``True`` else triangles Returns: :class:`~ezdxf.render.MeshTransformer` .. versionadded:: 0.11 """ radius = float(radius) slices = int(count) stacks_2 = int(stacks) // 2 # stacks from -stack/2 to +stack/2 delta_theta = pi * 2.0 / float(slices) delta_phi = pi / float(stacks) mesh = MeshVertexMerger() def radius_of_stack(stack: float) -> float: return radius * cos(delta_phi * stack) def vertex(slice_: float, r: float, z: float) -> Vector: actual_theta = delta_theta * slice_ return Vector(cos(actual_theta) * r, sin(actual_theta) * r, z) def cap_triangles(stack, top=False): z = sin(stack * delta_phi) * radius cap_vertex = Vector(0, 0, radius) if top else Vector(0, 0, -radius) r1 = radius_of_stack(stack) for slice_ in range(slices): v1 = vertex(slice_, r1, z) v2 = vertex(slice_ + 1, r1, z) if top: mesh.add_face((v1, v2, cap_vertex)) else: mesh.add_face((cap_vertex, v2, v1)) # bottom triangle faces cap_triangles(-stacks_2 + 1, top=False) # add body faces for actual_stack in range(-stacks_2 + 1, stacks_2 - 1): next_stack = actual_stack + 1 r1 = radius_of_stack(actual_stack) r2 = radius_of_stack(next_stack) z1 = sin(delta_phi * actual_stack) * radius z2 = sin(delta_phi * next_stack) * radius for i in range(slices): v1 = vertex(i, r1, z1) v2 = vertex(i + 1, r1, z1) v3 = vertex(i + 1, r2, z2) v4 = vertex(i, r2, z2) if quads: mesh.add_face([v1, v2, v3, v4]) else: center = vertex( i + 0.5, radius_of_stack(actual_stack + 0.5), sin(delta_phi * (actual_stack + 0.5)) * radius, ) mesh.add_face([v1, v2, center]) mesh.add_face([v2, v3, center]) mesh.add_face([v3, v4, center]) mesh.add_face([v4, v1, center]) # top triangle faces cap_triangles(stacks_2 - 1, top=True) return MeshTransformer.from_builder(mesh)