def solve_triangular_faces(self): """Modify the decomposition mesh from polylines to make it a quad mesh by converting the degenerated quad faces that appear as triangular faces. """ mesh = self.mesh for fkey in list(mesh.faces()): if len(mesh.face_vertices(fkey)) == 3: boundary_vertices = [vkey for vkey in mesh.face_vertices(fkey) if mesh.is_vertex_on_boundary(vkey)] case = sum(mesh.is_vertex_on_boundary(vkey) for vkey in mesh.face_vertices(fkey)) if case == 1: #convert triangular face to quad by duplicating the boundary vertex #due to compas_singular face vertices at the same location u = boundary_vertices[0] v = mesh.add_vertex(attr_dict = {attr: xyz for attr, xyz in zip(['x', 'y', 'z'], mesh.vertex_coordinates(u))}) # modify adjacent faces vertex_faces = mesh.vertex_faces(u, ordered = True) mesh_substitute_vertex_in_faces(mesh, u, v, vertex_faces[: vertex_faces.index(fkey)]) # modify triangular face mesh_insert_vertex_on_edge(mesh, u, mesh.face_vertex_ancestor(fkey, u), v) elif case == 2: # remove triangular face and merge the two boundary vertices # due to singularities at the same location polyline = Polyline(self.decomposition_polyline(*map(lambda x: geometric_key(mesh.vertex_coordinates(x)), boundary_vertices))) point = polyline.point(t = .5, snap = True) new_vkey = mesh.add_vertex(attr_dict = {'x': point.x, 'y': point.y , 'z': point.z}) # modify triangular face mesh.delete_face(fkey) # modify adjacent faces for old_vkey in boundary_vertices: mesh_substitute_vertex_in_faces(mesh, old_vkey, new_vkey, mesh.vertex_faces(old_vkey)) mesh.delete_vertex(old_vkey) to_move = {} # give some length to the new edge for edge in mesh.edges(): threshold = 1e-6 if mesh.edge_length(*edge) < threshold: for vkey in edge: xyz = centroid_points([mesh.vertex_coordinates(nbr) for nbr in mesh.vertex_neighbors(vkey)]) xyz0 = mesh.vertex_coordinates(vkey) to_move[vkey] = [0.1 * (a - a0) for a, a0 in zip(xyz, xyz0)] for vkey, xyz in to_move.items(): attr = mesh.vertex[vkey] attr['x'] += xyz[0] attr['y'] += xyz[1] attr['z'] += xyz[2]
def test_data(): p = Polyline([ Point(random.random(), random.random(), random.random()) for i in range(10) ]) assert p.data == p.validate_data() o = Polyline.from_data(p.data) assert p == o assert not (p is o) assert o.data == o.validate_data()
def test_equality(): points1 = [[0, 0, x] for x in range(5)] polyline1 = Polyline(points1) points2 = [[0, 0, x] for x in range(6)] polyline2 = Polyline(points2) assert polyline1 == polyline1 assert polyline1 == points1 assert points1 == polyline1 assert polyline1 != polyline2 assert polyline2 != polyline1 assert polyline1 != points2 assert points2 != polyline1 assert polyline1 != 1
def select_quad_mesh_strip(mesh, text='key'): """Select quad mesh strip. Parameters ---------- mesh : QuadMesh, CoarseQuadMesh The quad mesh or coarse quad mesh. text : str Optional argument to show the strip key or density. The key by default. Returns ------- hashable The strip key. """ n = mesh.number_of_strips() # different colors per strip strip_to_color = {skey: scale_vector([float(i), 0, n - 1 - float(i)], 255 / (n - 1)) for i, skey in enumerate(mesh.strips())} rs.EnableRedraw(False) # add strip polylines with colors and arrows guids_to_strip = {rs.AddPolyline(mesh.strip_edge_midpoint_polyline(skey)): skey for skey in mesh.strips()} for guid, skey in guids_to_strip.items(): rs.ObjectColor(guid, strip_to_color[skey]) rs.CurveArrows(guid, arrow_style = 3) # show strip key or density if text == 'key' or text == 'density': if text == 'key': guids_to_dot = {guid: rs.AddTextDot(skey, Polyline(mesh.strip_edge_midpoint_polyline(skey)).point(t = .5)) for guid, skey in guids_to_strip.items()} elif text == 'density': guids_to_dot = {guid: rs.AddTextDot(mesh.get_strip_density(skey), Polyline(mesh.strip_edge_midpoint_polyline(skey)).point(t = .5)) for guid, skey in guids_to_strip.items()} for guid, dot in guids_to_dot.items(): rs.ObjectColor(dot, rs.ObjectColor(guid)) # return polyline strip rs.EnableRedraw(True) skey = guids_to_strip.get(rs.GetObject('Get strip.', filter = 4), None) rs.EnableRedraw(False) # delete objects rs.DeleteObjects(guids_to_strip.keys()) if text == 'key' or text == 'density': rs.DeleteObjects(guids_to_dot.values()) return skey
def test___getitem__(): points = [[0, 0, x] for x in range(5)] polyline = Polyline(points) for x in range(5): assert polyline[x] == [0, 0, x] with pytest.raises(IndexError): polyline[6] = [0, 0, 6]
def to_compas(self): """Convert the curve to an equivalent geometry object. Returns ------- :class:`compas.geometry.Line` If the curve is a line (if it is a linear segment between two points). :class:`compas.geometry.Polyline` If the curve is a polyline (if it is comprised of multiple line segments). :class:`compas.geometry.Circle` If the curve is a circle. """ if self.is_line(): return Line(self.start, self.end) if self.is_polyline(): return Polyline(self.points) if self.is_circle(): success, circle = self.geometry.TryGetCircle() if not success: raise Exception("not a circle") plane = circle.Plane center = plane.Origin normal = plane.Normal radius = circle.Radius return Circle([center, normal], radius)
def visualize_on_viewer(self, viewer, visualize_mesh=False, visualize_paths=True): """Visualizes slicing result using compas.viewers. Parameters ---------- viewer: :class:`compas_view2.app.App` An instance of the App viewer class. visualize_mesh: bool, optional True to visualize mesh, False to not. visualize_paths: bool, optional True to visualize paths, False to not. """ if visualize_mesh: viewer.add(self.mesh, show_points=False, hide_coplanaredges=False) if visualize_paths: for i, layer in enumerate(self.layers): for j, path in enumerate(layer.paths): pts = copy.deepcopy(path.points) if path.is_closed: pts.append(pts[0]) polyline = Polyline(pts) viewer.add(polyline, show_points=True, pointcolor=(0, 0, 1), linecolor=(1, 0, 0), linewidth=2)
def test___setitem__(): points = [[0, 0, x] for x in range(5)] polyline = Polyline(points) point = [1, 1, 4] polyline[4] = point assert polyline[4] == point assert isinstance(polyline[4], Point) assert polyline.lines[-1].end == point
def add_vertex_edge_for_load_support(network, sup_dic, load_dic, bars_len, key_removed_dic): """ Post-Processing Function: Adds vertices and edges in accordance with supports and loads returns the cured network """ if not key_removed_dic: load_sup_dic=merge_two_dicts(sup_dic, load_dic) else: load_dic_2=load_dic.copy() for key in key_removed_dic: load_dic_2.pop(key) load_dic_2=merge_two_dicts(load_dic_2, key_removed_dic[key]) load_sup_dic=merge_two_dicts(sup_dic, load_dic_2) # define arbitrary r to be added to get leaf vertex coordinates max_len=max(bars_len) r=max_len/3.0 # make a polygon and polyline from outer vertices of network points = network.to_points() cycles = network_find_cycles(network) mesh = Mesh.from_vertices_and_faces(points, cycles) if 0 in mesh.face and len(mesh.face)>1: mesh.delete_face(0) if len(mesh.face)==1: ver_lis=[key for key in mesh.vertices()] else: ver_lis=mesh.vertices_on_boundary(ordered=True) ver_lis_plyln=ver_lis[:] ver_lis_plyln.append(ver_lis[0]) pt_lis_plygn=[mesh.vertex_coordinates(key) for key in ver_lis] pt_lis_plyln=[mesh.vertex_coordinates(key) for key in ver_lis_plyln] plygn=Polygon(pt_lis_plygn) plyln=Polyline(pt_lis_plyln) # add leaf vertices for key in load_sup_dic: if load_sup_dic[key][0]!=0.0: pt_1=add_vectors(network.node_coordinates(key), (+r, 0.0, 0.0)) plyln_bln=is_point_on_polyline(pt_1, plyln.points, tol=0.001) plygn_bln=is_point_in_polygon_xy(pt_1, plygn.points) if plyln_bln or plygn_bln: pt_1=add_vectors(network.node_coordinates(key), (-r, 0.0, 0.0)) key_2=network.add_node(x=np.asscalar(pt_1[0]), y=pt_1[1], z=0.0) network.add_edge(key, key_2) if load_sup_dic[key][1]!=0.0: pt_2=add_vectors(network.node_coordinates(key), (0.0,+r, 0.0)) plyln_bln=is_point_on_polyline(pt_2, plyln.points, tol=0.001) plygn_bln=is_point_in_polygon_xy(pt_2, plygn.points) if plyln_bln or plygn_bln: pt_2=add_vectors(network.node_coordinates(key), (0.0,-r, 0.0)) key_2=network.add_node(x=pt_2[0], y=np.asscalar(pt_2[1]), z=0.0) network.add_edge(key, key_2) return network, plygn, plyln
def automated_smoothing_constraints(mesh, points = None, curves = None, surface = None, mesh2 = None): """Apply automatically point, curve and surface constraints to the vertices of a mesh to smooth. Parameters ---------- mesh : Mesh The mesh to apply the constraints to for smoothing. points : list List of XYZ coordinates on which to constrain mesh vertices. Default is None. curves : list List of Rhino curve guids on which to constrain mesh vertices. Default is None. surface : Rhino surface guid A Rhino surface guid on which to constrain mesh vertices. Default is None. mesh2 : Rhino mesh guid A Rhino mesh guid on which to constrain mesh vertices. Default is None. Returns ------- constraints : dict A dictionary of mesh constraints for smoothing as vertex keys pointing to point, curve or surface objects. """ if surface: surface = RhinoSurface.from_guid(surface) if curves: curves = [RhinoCurve.from_guid(curve) for curve in curves] if mesh2: mesh2 = RhinoMesh.from_guid(mesh2) constraints = {} constrained_vertices = {} vertices = list(mesh.vertices()) vertex_coordinates = [mesh.vertex_coordinates(vkey) for vkey in mesh.vertices()] if points is not None and len(points) != 0: constrained_vertices.update({vertices[closest_point_in_cloud(rs.PointCoordinates(point), vertex_coordinates)[2]]: point for point in points}) if mesh2 is not None: constraints.update({vkey: mesh2.guid for vkey in mesh.vertices()}) if surface is not None: constraints.update({vkey: surface.guid for vkey in mesh.vertices()}) if curves is not None and len(curves) != 0: boundaries = [split_boundary for boundary in mesh.boundaries() for split_boundary in list_split(boundary, [boundary.index(vkey) for vkey in constrained_vertices.keys() if vkey in boundary])] boundary_midpoints = [Polyline([mesh.vertex_coordinates(vkey) for vkey in boundary]).point(t = .5) for boundary in boundaries] curve_midpoints = [rs.EvaluateCurve(curve, rs.CurveParameter(curve, .5)) for curve in curves] midpoint_map = {i: closest_point_in_cloud(boundary_midpoint, curve_midpoints)[2] for i, boundary_midpoint in enumerate(boundary_midpoints)} constraints.update({vkey: curves[midpoint_map[i]].guid for i, boundary in enumerate(boundaries) for vkey in boundary}) if points is not None: constraints.update(constrained_vertices) return constraints
def resample_curve_compas(self, length): try: # rs_poly = rs.AddPolyline(self.polyline.points) polyline = Polyline(self.polyline.points) if length <= self.polyline.length: points = polyline.divide_polyline_by_length(length) tangents = [ polyline.tangent_at_point_on_polyline(p) for p in points ] points = [(p.x, p.y, p.z) for p in points] tangents = [(t.x, t.y, t.z) for t in tangents] return points, tangents except Exception: print('Interpolated Curve could not be resampled.') return None, None
def calculate_circle_centre_and_radius_from_three_pts(three_pts_list): """ points is compas Point """ A = three_pts_list[0] B = three_pts_list[1] C = three_pts_list[2] vBA = B - A vBC = C - B normVec = vBA.cross(vBC) midBA = (B + A) / 2 midBC = (B + C) / 2 vec_BA = vBA.cross(normVec) vec_BC = vBC.cross(normVec) poly_0 = Polyline([midBA + vec_BA * 10, midBA - vec_BA * 10]) poly_1 = Polyline([midBC - vec_BC * 10, midBC + vec_BC * 10]) centrePt = get_intersection_pts_two_polyline(poly_0, poly_1, touch=True) radius = round(centrePt.distance_to_point(B), 3) return centrePt, radius
def polyline_to_compas(polyline): """Convert a Rhino polyline to a COMPAS polyline. Parameters ---------- polyline : :class:`Rhino.Geometry.Polyline` Returns ------- :class:`compas.geometry.Polyline` """ return Polyline([point_to_compas(point) for point in polyline])
def get_layer_ppts(self, layer, base_boundary): """ Creates the PrintPoints of a single layer.""" max_layer_height = get_param(self.parameters, key='max_layer_height', defaults_type='layers') min_layer_height = get_param(self.parameters, key='min_layer_height', defaults_type='layers') avg_layer_height = get_param(self.parameters, 'avg_layer_height', 'layers') all_pts = [pt for path in layer.paths for pt in path.points] closest_fks, projected_pts = utils.pull_pts_to_mesh_faces( self.slicer.mesh, all_pts) normals = [ Vector(*self.slicer.mesh.face_normal(fkey)) for fkey in closest_fks ] count = 0 crv_to_check = Path( base_boundary.points, True) # creation of fake path for the lower boundary layer_ppts = {} for i, path in enumerate(layer.paths): layer_ppts['path_%d' % i] = [] for p in path.points: cp = closest_point_on_polyline(p, Polyline(crv_to_check.points)) d = distance_point_point(cp, p) ppt = PrintPoint(pt=p, layer_height=avg_layer_height, mesh_normal=normals[count]) ppt.closest_support_pt = Point(*cp) ppt.distance_to_support = d ppt.layer_height = max(min(d, max_layer_height), min_layer_height) ppt.up_vector = Vector( *normalize_vector(Vector.from_start_end(cp, p))) ppt.frame = ppt.get_frame() layer_ppts['path_%d' % i].append(ppt) count += 1 crv_to_check = path return layer_ppts
def to_compas(self): if self.is_line(): return Line(self.start, self.end) if self.is_polyline(): return Polyline(self.points) if self.is_circle(): success, circle = self.geometry.TryGetCircle() if not success: raise Exception("not a circle") plane = circle.Plane center = plane.Origin normal = plane.Normal radius = circle.Radius return Circle([center, normal], radius)
def test_slicer(): FILE = os.path.join(HERE, '../..', 'data', '3DBenchy.stl') # ============================================================================== # Get benchy and construct a mesh # ============================================================================== benchy = Mesh.from_stl(FILE) # ============================================================================== # Create planes # ============================================================================== # replace by planes along a curve bbox = benchy.bounding_box() x, y, z = zip(*bbox) zmin, zmax = min(z), max(z) normal = Vector(0, 0, 1) planes = [] for i in np.linspace(zmin, zmax, 50): plane = Plane(Point(0, 0, i), normal) planes.append(plane) # ============================================================================== # Slice # ============================================================================== M = benchy.to_vertices_and_faces() pointsets = slice_mesh(M, planes) # ============================================================================== # Process output # ============================================================================== polylines = [] for points in pointsets: points = [Point(*point) for point in points] polyline = Polyline(points) polylines.append(polyline)
def create_pair_point_list_between_boundaries(pts_list_00, pts_list_01): """ these point list have compas point data """ pts_00 = [pt for pt in pts_list_00] pts_01 = [pt for pt in pts_list_01] pair_lines = [] pairs = [] num = len(pts_00) pts_exis_00 = [] pts_exis_01 = [] for k in range(num): for pt_00 in pts_00: skip = [] for i in range(len(pts_01)): closestPt_01 = select_closest_pt_from_list(pt_00, pts_01, skip) skip_pts = [] closest_pt_00_check = select_closest_pt_from_list(closestPt_01, pts_00, skip_pts) if closest_pt_00_check == pt_00: closestPt = closestPt_01 pts_exis_01.append(closestPt) pts_exis_00.append(pt_00) pair = [pt_00, closestPt] pairs.append(pair) pair_line = Polyline(pair) pair_lines.append(pair_line) break id_00 = pts_00.index(pts_exis_00[-1]) id_01 = pts_01.index(pts_exis_01[-1]) pts_00.pop(id_00) pts_01.pop(id_01) ## array lines ## pairs_arrayed = [] pts_00 = [pt for pt in pts_list_00] for pt_00 in pts_00: for pair in pairs: if pt_00 in pair and pair not in pairs_arrayed: pairs_arrayed.append(pair) return pairs_arrayed, pair_lines
def visualize_on_viewer(self, viewer, visualize_printpoints): """Visualize printpoints on the compas_viewer. Parameters ---------- viewer: :class:`compas_view2.app.App` An instance of the App viewer class. visualize_printpoints: bool """ all_pts = [] for layer_key in self.printpoints_dict: for path_key in self.printpoints_dict[layer_key]: for printpoint in self.printpoints_dict[layer_key][path_key]: all_pts.append(printpoint.pt) polyline = Polyline(all_pts) viewer.add(polyline, show_points=visualize_printpoints, pointcolor=(0, 0, 1), linecolor=(1, 0, 1), linewidth=1)
from compas_occ.geometry import OCCNurbsCurve from compas_view2.app import App pointsA = [Point(0, 0, 0), Point(3, 6, 0), Point(6, -3, 3), Point(10, 0, 0)] curveA = OCCNurbsCurve.from_points(pointsA) curveA.segment(u=0.2, v=0.5) print(curveA.domain) pointsB = [Point(0, -1, 0), Point(3, 5, 0), Point(6, -4, 3), Point(10, -1, 0)] curveB = OCCNurbsCurve.from_points(pointsB) segment = curveB.segmented(u=0.2, v=0.5) print(curveB.domain) print(segment.domain) # ============================================================================== # Visualisation # ============================================================================== view = App() view.add(Polyline(curveA.locus()), linewidth=4, linecolor=(1, 0, 0)) view.add(Polyline(curveB.locus()), linewidth=1, linecolor=(0, 0, 0)) view.add(Polyline(segment.locus()), linewidth=4, linecolor=(0, 1, 0)) view.run()
def bezier_curve_from_two_vectors(start_end_pts, start_end_vectors, resolutionNum=10, degree=0.5, is_node=False): """ create a bezier curve points from two vectors on the start point and end point direction of the vectors is the same with the flow of the bezier curve points """ ## control points ## if is_node: flip_vec = 1 else: flip_vec = -1 distance = start_end_pts[0].distance_to_point(start_end_pts[1]) start_vector = start_end_vectors[0].unitized() start_vector = start_vector * distance * degree * (1) end_vector = start_end_vectors[1].unitized() end_vector = end_vector * distance * degree * (flip_vec) control_pt_0 = start_end_pts[0] + start_vector control_pt_1 = start_end_pts[1] + end_vector pts = [start_end_pts[0], control_pt_0, control_pt_1, start_end_pts[1]] ############################################################################ bezier_pts = [] pts_list = [] for i in range(len(pts) - 2): pts_sub = pts[i:3 + i] pts_list.append(pts_sub) for pts in pts_list: lines_second = [] for j in range(resolutionNum + 1): control_linestring = zip(pts[:-1], pts[1:]) time = j / resolutionNum pts_new = [] for pt1, pt2 in control_linestring: pt = pt1 * (1 - time) + pt2 * (time) pts_new.append(pt) line = Polyline(pts_new) lines_second.append(line) bezier_pts_sub = [] control_string = zip(lines_second[:-1], lines_second[1:]) for line1, line2 in control_string: # print("line1 :", line1) # print("line2 ;", line2) intersecPts = get_intersection_pts_two_polyline(line1, line2, touch=True) bezier_pts_sub.append(intersecPts) bezier_pts.append(bezier_pts_sub) first_half = bezier_pts[0] second_half = bezier_pts[1] bezier = [] number = len(first_half) for i in range(number): t = (i / (number - 1)) pt_first_half = first_half[i] pt_second_half = second_half[i] pt = pt_first_half * (1 - t) + pt_second_half * (t) bezier.append(pt) bezier.insert(0, start_end_pts[0]) bezier.append(start_end_pts[1]) return bezier
surface.transform(R * T) # ============================================================================== # AABB # ============================================================================== box = surface.aabb() # ============================================================================== # Visualisation # ============================================================================== view = App() for row in surface.points: view.add(Polyline(row), show_points=True, pointsize=20, pointcolor=(1, 0, 0), linewidth=2, linecolor=(1.0, 0, 0)) for col in zip(*surface.points): view.add(Polyline(col), linewidth=2, linecolor=(0, 1.0, 0)) view.add(surface.to_mesh(), show_edges=False) view.add(box, show_faces=False) view.run()
from compas.geometry import Vector, Point, Plane from compas.geometry import Polyline from compas.geometry import Circle from compas_occ.geometry import OCCNurbsCurve from compas_view2.app import App circle = Circle(Plane(Point(0, 0, 0), Vector(0, 0, 1)), 1.0) curve = OCCNurbsCurve.from_circle(circle) # ============================================================================== # Visualisation # ============================================================================== view = App() view.add(Polyline(curve.locus()), linewidth=3) view.add(Polyline(curve.points), show_points=True, pointsize=20, pointcolor=(1, 0, 0), linewidth=1, linecolor=(0.3, 0.3, 0.3)) view.run()
isolines = igl.groupsort_isolines(vertices, edges) # ============================================================================== # Visualisation # ============================================================================== viewer = ObjectViewer() viewer.add(mesh, settings={ 'color': '#ffffff', 'vertices.on': False, 'edges.on': False }) cmap = Colormap(scalars, 'rgb') for value, paths in isolines: for path in paths: points = [vertices[path[0][0]]] for i, j in path: points.append(vertices[j]) viewer.add(Polyline(points), settings={ 'edges.color': rgb_to_hex(cmap(value)), 'edges.width': 5, 'vertices.on': False }) viewer.update() viewer.show()
from compas.geometry import Point from compas.geometry import Polyline from compas.geometry import NurbsCurve from compas.artists import Artist from compas.colors import Color points = [Point(0, 0, 0), Point(3, 6, 0), Point(6, -3, 3), Point(10, 0, 0)] curve = NurbsCurve.from_points(points) # ============================================================================== # Visualisation # ============================================================================== Artist.clear() Artist(curve).draw(color=Color.green()) Artist(Polyline(curve.points)).draw(show_points=True) Artist.redraw()
# ============================================================================== # Compute the intersections # ============================================================================== proxy.package = 'compas_cgal.intersections' pointsets = proxy.intersection_mesh_mesh(A, B) # ============================================================================== # Process output # ============================================================================== polylines = [] for points in pointsets: points = [Point(*point) for point in points] polyline = Polyline(points) polylines.append(polyline) # ============================================================================== # Visualize # ============================================================================== meshartist = MeshArtist(None) meshartist.mesh = Mesh.from_vertices_and_faces(*A) meshartist.layer = "CGAL::Intersections::A" meshartist.clear_layer() meshartist.draw_faces(join_faces=True, color=hex_to_rgb('#222222')) meshartist.mesh = Mesh.from_vertices_and_faces(*B) meshartist.layer = "CGAL::Intersections::B"
# ============================================================================== # JSON Data # ============================================================================== string = surface.to_jsonstring(pretty=True) print(string) other = NurbsSurface.from_jsonstring(string) # print(surface == other) # ============================================================================== # Visualisation # ============================================================================== Artist.clear() u = surface.u_isocurve(0.5 * sum(surface.u_domain)) v = surface.v_isocurve(0.5 * sum(surface.v_domain)) Artist(Polyline(u.locus())).draw() Artist(Polyline(v.locus())).draw() # for curve in surface.boundary(): # Artist(Polyline(curve.locus())).draw() Artist(other).draw() Artist.redraw()
from compas.geometry import Bezier from compas.geometry import Point, Polyline, Vector from compas.geometry import offset_polyline from compas.utilities import linspace from compas_plotters import GeometryPlotter controlpoints = [ Point(0, 0, 0), Point(4, 2.5, 0), Point(6, -2.5, 0), Point(10, 0, 0) ] controlpoly = Polyline(controlpoints) curve = Bezier(controlpoints) poly = Polyline(curve.locus()) poly1 = Polyline(offset_polyline(poly, +0.15)) poly2 = Polyline(offset_polyline(poly, -0.15)) points = [curve.point(t) for t in linspace(0, 1, 20)] tangents = [curve.tangent(t) for t in linspace(0, 1, 20)] normals = [Vector(0, 0, 1).cross(t) for t in tangents] # ============================================================================== # Visualization # ============================================================================== plotter = GeometryPlotter(figsize=(16, 9)) plotter.add(controlpoly,
def fix_boundaries(mesh, polyline_points, t=0): polyline = Polyline(polyline_points) n = len(mesh.vertices_on_boundary()) for i, vkey in enumerate(mesh.boundaries()[0]): xyz = polyline.point((t + i / n) % 1.0) mesh_move_vertex_to(mesh, xyz, vkey)
for j, (u, v) in enumerate(zip(U, V)): if i == 0 or i == 5 or j == 0 or j == 8: z = 0.0 elif i < 2 or i > 3: z = -1.0 else: if j < 2 or j > 6: z = -1.0 else: z = Z row.append(Point(u, v, z)) points.append(row) surface = NurbsSurface.from_points(points=points) # ============================================================================== # Visualisation # ============================================================================== Artist.clear() for row in surface.points: Artist(Polyline(row)).draw() for col in zip(*list(surface.points)): Artist(Polyline(col)).draw() Artist(surface).draw() Artist.redraw()
for line in zip(left_points, right_points): left_x = intersection_line_plane(line, left_plane) right_x = intersection_line_plane(line, right_plane) left_intersections.append(left_x) right_intersections.append(right_x) left_intersections.append(left_intersections[1]) right_intersections.append(right_intersections[1]) left_intersections.append(left_intersections[0]) right_intersections.append(right_intersections[0]) # polylines left_poly = Polyline(left_intersections) right_poly = Polyline(right_intersections) # ============================================================================== # Export # ============================================================================== block.attributes['sides'] = {'left': left, 'right': right} block.attributes['cut1'] = {'left': left_poly, 'right': right_poly} block.to_json(FILE_O) # ============================================================================== # Visualization # ==============================================================================