def generate_tiles(tile_settings): radius, angle, scale, separate, grid_list, sides = tile_settings vert_grid_list, edge_grid_list, poly_grid_list = [[], [], []] local_angle = 45 if sides == 4 else 30 tile = circle(radius*scale, radians(local_angle - angle), sides, None, 'pydata') for grid in grid_list: vert_list, edge_list, poly_list = [[], [], []] if sides == 3: tiles_triangular(vert_list, edge_list, poly_list, tile, grid) else: tiles(vert_list, edge_list, poly_list, tile, grid) if not separate: vert_list, edge_list, poly_list = mesh_join(vert_list, edge_list, poly_list) if scale == 1.0: vert_list, edge_list, poly_list = remove_doubles(vert_list, [], poly_list, 0.001) vert_grid_list.append(vert_list) edge_grid_list.append(edge_list) poly_grid_list.append(poly_list) return vert_grid_list, edge_grid_list, poly_grid_list
def generate_tiles(radius, angle, separate, gridList): verts, edges, polys = circle(radius, radians(30 - angle), 6, None, 'pydata') vertGridList, edgeGridList, polyGridList = [[], [], []] for grid in gridList: vertList, edgeList, polyList = [[], [], []] addVert, addEdge, addPoly = [ vertList.append, edgeList.append, polyList.append ] for cx, cy, _ in grid: verts2 = [(x + cx, y + cy, 0.0) for x, y, _ in verts] addVert(verts2) addEdge(edges) addPoly(polys) if not separate: vertList, edgeList, polyList = mesh_join(vertList, edgeList, polyList) vertGridList.append(vertList) edgeGridList.append(edgeList) polyGridList.append(polyList) return vertGridList, edgeGridList, polyGridList
def main_func(self, params): out_verts, out_edges, out_faces = [], [], [] for A, B, C, a, b, c, alpha, beta in zip(*params): if self.angle_mode == 'Degrees': alpha = radians(alpha) beta = radians(beta) if self.mode == 'A_Bv_C': verts = [A, B, C] if self.mode == 'A_c_Alpha_Beta': verts = triang_A_c_Alpha_Beta(A, c, alpha, beta) elif self.mode == 'A_Bv_Alpha_Beta': verts = triang_A_B_Alpha_Beta(A, B, alpha, beta) elif self.mode == 'A_Bv_as_b': verts = triang_A_B_a_b(A, B, a, b) elif self.mode == 'A_as_b_c': verts = triang_A_a_b_c(A, a, b, c) elif self.mode == 'A_b_c_Alpha': verts = triang_A_b_c_Alpha(A, b, c, alpha) elif self.mode == 'A_Bv_b_Alpha': verts = triang_A_B_b_Alpha(A, B, b, alpha) out_verts.append(verts) out_edges.append([[0, 1], [1, 2], [2, 0]]) out_faces.append([[0, 1, 2]]) if self.join_level: out_verts, out_edges, out_faces = mesh_join( out_verts, out_edges, out_faces) if self.rm_doubles: out_verts, out_edges, out_faces = remove_doubles( out_verts, out_edges, out_faces, self.epsilon) out_verts, out_edges, out_faces = [out_verts], [out_edges ], [out_faces] return out_verts, out_edges, out_faces
def generate_penta_tiles(tile_settings, grid, separate, pentagon_type): angle, _, _, A, B, a, b, c, d = tile_settings vert_grid_list, edge_grid_list, poly_grid_list = [[], [], []] tile = pentagon([A, B], [a, b, c, d], pentagon_type) angle2 = angle + grid[0][2] cosa = cos(angle2) sina = sin(angle2) tile[0] = [[v[0] * cosa - v[1] * sina, v[0] * sina + v[1] * cosa, 0] for v in tile[0]] vert_list, edge_list, poly_list = [[], [], []] if pentagon_type in ['PENTAGON2']: tiles_alterned(vert_list, edge_list, poly_list, tile, grid) else: tiles(vert_list, edge_list, poly_list, tile, grid) if not separate: vert_list, edge_list, poly_list = mesh_join(vert_list, edge_list, poly_list) vert_list, edge_list, poly_list = remove_doubles( vert_list, edge_list, poly_list, 1e-5) vert_grid_list.append(vert_list) edge_grid_list.append(edge_list) poly_grid_list.append(poly_list) return vert_grid_list, edge_grid_list, poly_grid_list
def process(self): if not self.inputs['Matrices'].is_linked: return vertices = self.inputs['Vertices'].sv_get() matrices = self.inputs['Matrices'].sv_get() n = len(matrices) result_vertices = (vertices * n)[:n] outV = [] for i, i2 in zip(matrices, result_vertices): outV.append([(i @ Vector(v))[:] for v in i2]) edges = self.inputs['Edges'].sv_get(default=[[]]) faces = self.inputs['Faces'].sv_get(default=[[]]) result_edges = (edges * n)[:n] result_faces = (faces * n)[:n] if self.do_join: outV, result_edges, result_faces = mesh_join( outV, result_edges, result_faces) outV, result_edges, result_faces = [outV], [result_edges ], [result_faces] self.outputs['Edges'].sv_set(result_edges) self.outputs['Faces'].sv_set(result_faces) self.outputs['Vertices'].sv_set(outV)
def generate_outlines(self, output_lists, params): verts_in, _, _, edges_in = params is_edges_in_linked = self.inputs['Edges_in'].is_linked poligonal_inter = (0 if self.intersecction_handle == "Circular" else 1) v_len = len(verts_in) edges_in = [i for i in edges_in if i[0] < v_len and i[1] < v_len] perimeter_number, actual_radius = self.get_perimeter_and_radius(params) for i in range(perimeter_number): net, parameters = self.adjust_parameters(params, v_len, actual_radius[i], poligonal_inter, edges_in) verts_in, _, actual_radius[i], net = parameters start_geometry = [self.make_verts(vi, v, r, n) for vi, v, r, n in zip(*parameters)] edg = [p[1] for p in start_geometry] points = [p[0] for p in start_geometry] if is_edges_in_linked: verts_sides_out, edge_side_out = self.side_edges(verts_in, edges_in, actual_radius[i], net) points.append(verts_sides_out) edg.append(edge_side_out) verts_out, _, edges_out = mesh_join(points, [], edg) verts_out, edges_out = intersect_edges_2d(verts_out, edges_out) edges_out = self.mask_edges_by_mid_points(verts_out, edges_out, parameters, v_len, edges_in) verts_out, edges_out = remove_doubles_from_edgenet(verts_out, edges_out, self.rm_doubles) verts_out, edges_out = sort_verts_by_connexions(verts_out, edges_out) output_lists[0].append(verts_out) output_lists[1].append(edges_out)
def process(self): if not self.outputs['Vertices'].is_linked: return vertices = self.inputs['Vertices'].sv_get() vertices = Vector_generate(vertices) edges = self.inputs['Edges'].sv_get(default=[[]]) faces = self.inputs['Faces'].sv_get(default=[[]]) matrices = self.inputs['Matrices'].sv_get() matrices = Matrix_generate(matrices) n = len(matrices) result_vertices = self.apply(vertices, matrices) result_vertices = Vector_degenerate(result_vertices) self.outputs['Vertices'].sv_set(result_vertices) if self.outputs['Edges'].is_linked or self.outputs['Faces'].is_linked: result_edges = edges * n result_faces = faces * n if self.do_join: result_vertices, result_edges, result_faces = mesh_join(result_vertices, result_edges, result_faces) if self.outputs['Edges'].is_linked: self.outputs['Edges'].sv_set(result_edges) if self.outputs['Faces'].is_linked: self.outputs['Faces'].sv_set(result_faces)
def generate_tiles(tile_settings): radius, angle, scale, separate, grid_list, sides = tile_settings vert_grid_list, edge_grid_list, poly_grid_list = [[], [], []] local_angle = 45 if sides == 4 else 30 tile = circle(radius*scale, radians(local_angle - angle), sides, None, 'pydata') for grid in grid_list: vert_list, edge_list, poly_list = [[], [], []] if sides == 3: tiles_triangular(vert_list, edge_list, poly_list, tile, grid) else: tiles(vert_list, edge_list, poly_list, tile, grid) if not separate: vert_list, edge_list, poly_list = mesh_join(vert_list, edge_list, poly_list) if scale == 1.0: vert_list, edge_list, poly_list, _ = remove_doubles(vert_list, poly_list, 0.01, False) vert_grid_list.append(vert_list) edge_grid_list.append(edge_list) poly_grid_list.append(poly_list) return vert_grid_list, edge_grid_list, poly_grid_list
def process(self): if not any(output.is_linked for output in self.outputs): return verts_recpt_s = self.inputs['VersR'].sv_get(deepcopy=False) faces_recpt_s = self.inputs['PolsR'].sv_get(default=[[]], deepcopy=False) verts_donor_s = self.inputs['VersD'].sv_get() faces_donor_s = self.inputs['PolsD'].sv_get() zcoefs_s = self.inputs['Z_Coef'].sv_get(deepcopy=False) zoffsets_s = self.inputs['Z_Offset'].sv_get(deepcopy=False) zrotations_s = self.inputs['Z_Rotation'].sv_get(deepcopy=False) wcoefs_s = self.inputs['W_Coef'].sv_get(deepcopy=False) if 'FrameWidth' in self.inputs: frame_widths_s = self.inputs['FrameWidth'].sv_get(deepcopy=True) else: frame_widths_s = [[0.5]] if 'PolyRotation' in self.inputs: facerots_s = self.inputs['PolyRotation'].sv_get(default = [[0]], deepcopy=False) else: facerots_s = [[0]] mask_s = self.inputs['PolyMask'].sv_get(default = [[1]], deepcopy=False) output = OutputData() if self.matching_mode == 'PERFACE': verts_donor_s = [verts_donor_s] faces_donor_s = [faces_donor_s] #self.info("FW: %s", frame_widths_s) #frame_widths_s = [frame_widths_s] objects = match_long_repeat([verts_recpt_s, faces_recpt_s, verts_donor_s, faces_donor_s, frame_widths_s, zcoefs_s, zoffsets_s, zrotations_s, wcoefs_s, facerots_s, mask_s]) #self.info("N objects: %s", len(list(zip(*objects)))) for verts_recpt, faces_recpt, verts_donor, faces_donor, frame_widths, zcoefs, zoffsets, zrotations, wcoefs, facerots, mask in zip(*objects): n_faces_recpt = len(faces_recpt) fullList(zcoefs, n_faces_recpt) fullList(zoffsets, n_faces_recpt) fullList(zrotations, n_faces_recpt) if get_data_nesting_level(frame_widths) < 1: frame_widths = [frame_widths] fullList(frame_widths, n_faces_recpt) fullList(wcoefs, n_faces_recpt) fullList(facerots, n_faces_recpt) mask = cycle_for_length(mask, n_faces_recpt) new = self._process(verts_recpt, faces_recpt, verts_donor, faces_donor, frame_widths, zcoefs, zoffsets, zrotations, wcoefs, facerots, mask) output.verts_out.extend(new.verts_out) output.faces_out.extend(new.faces_out) output.verts_out = Vector_degenerate(output.verts_out) if self.join: output.verts_out, _, output.faces_out = mesh_join(output.verts_out, [], output.faces_out) output.verts_out = [output.verts_out] output.faces_out = [output.faces_out] self.outputs['Vertices'].sv_set(output.verts_out) self.outputs['Polygons'].sv_set(output.faces_out)
def apply_nested_matrices_py( vertices: List[PyVertices], edges: List[PyEdges], faces: List[PyFaces], matrices: List[List[Matrix]], do_join: bool ) -> Tuple[List[PyVertices], List[PyEdges], List[PyFaces]]: # Get list of Sverchok meshes and list of list of matrices # List of matrices applies to a mesh, each matrices copy the mesh inside an object max_objects = max( [len(func_input) for func_input in [vertices, edges, faces, matrices]]) vertices = repeat_last(vertices) edges = repeat_last(edges) faces = repeat_last(faces) matrices = repeat_last(matrices) meshes: List[Tuple[PyVertices, PyEdges, PyFaces]] = [] for i, obj_vertices, obj_edges, obj_faces, obj_matrices in zip( range(max_objects), vertices, edges, faces, matrices): meshes.append( copy_object_and_transform_py(obj_vertices, obj_edges, obj_faces, obj_matrices)) if do_join: mesh = mesh_join(*list(zip(*meshes))) return [[mesh_element] for mesh_element in mesh] else: return list(zip(*meshes))
def random_subdiv_mesh(verts_m, pols_m, iteration): verts, faces = [], [] for pol in pols_m: verts_out, faces_out = [], [] new_quad = faces_out.append pts = sort(verts_m, pol) X = 0.5 + (random.random() - 0.5) * random_factor Y = 0.5 + (random.random() - 0.5) * random_factor pos_a = lerp(pts[0], pts[1], Y) pos_b = lerp(pts[1], pts[2], X) pos_c = lerp(pts[3], pts[2], 1 - Y) pos_d = lerp(pts[0], pts[3], X) pos_e = lerp(pos_d, pos_b, Y) pos_f = lerp(pos_d, pos_b, 1 - Y) # indices = 0, 1, 2, 3 verts_out.extend(pts) # indices = 4, 5, 6, 7, 8, 9 verts_out.extend([pos_a, pos_b, pos_c, pos_d, pos_e, pos_f]) new_quad([0, 4, 8, 7]) new_quad([4, 1, 5, 8]) new_quad([5, 2, 6, 9]) new_quad([7, 9, 6, 3]) faces.append(faces_out) verts.append(verts_out) verts, _, faces = mesh_join(verts, [], faces) if iteration < 2: return verts, faces else: return random_subdiv_mesh(verts, faces, iteration - 1)
def process(self): if not self.outputs['Vertices'].is_linked: return vertices = self.inputs['Vertices'].sv_get() vertices = Vector_generate(vertices) edges = self.inputs['Edges'].sv_get(default=[[]]) faces = self.inputs['Faces'].sv_get(default=[[]]) matrices = self.inputs['Matrices'].sv_get() matrices = Matrix_generate(matrices) n = len(matrices) result_vertices = self.apply(vertices, matrices) result_vertices = Vector_degenerate(result_vertices) self.outputs['Vertices'].sv_set(result_vertices) if self.outputs['Edges'].is_linked or self.outputs['Faces'].is_linked: result_edges = edges * n result_faces = faces * n if self.do_join: result_vertices, result_edges, result_faces = mesh_join( result_vertices, result_edges, result_faces) if self.outputs['Edges'].is_linked: self.outputs['Edges'].sv_set(result_edges) if self.outputs['Faces'].is_linked: self.outputs['Faces'].sv_set(result_faces)
def process(self): if not any(socket.is_linked for socket in self.outputs): return field_s = self.inputs['Field'].sv_get() bounds_s = self.inputs['Bounds'].sv_get() scale_s = self.inputs['Scale'].sv_get() samples_x_s = self.inputs['SamplesX'].sv_get() samples_y_s = self.inputs['SamplesY'].sv_get() samples_z_s = self.inputs['SamplesZ'].sv_get() verts_out = [] edges_out = [] inputs = zip_long_repeat(field_s, bounds_s, scale_s, samples_x_s, samples_y_s, samples_z_s) for field, bounds, scale, samples_x, samples_y, samples_z in inputs: if isinstance(samples_x, (list, tuple)): samples_x = samples_x[0] if isinstance(samples_y, (list, tuple)): samples_y = samples_y[0] if isinstance(samples_z, (list, tuple)): samples_z = samples_z[0] if isinstance(scale, (list, tuple)): scale = scale[0] b1, b2 = self.get_bounds(bounds) b1n, b2n = np.array(b1), np.array(b2) self.debug("Bounds: %s - %s", b1, b2) x_range = np.linspace(b1[0], b2[0], num=samples_x) y_range = np.linspace(b1[1], b2[1], num=samples_y) z_range = np.linspace(b1[2], b2[2], num=samples_z) xs, ys, zs = np.meshgrid(x_range, y_range, z_range, indexing='ij') xs, ys, zs = xs.flatten(), ys.flatten(), zs.flatten() points = np.stack((xs, ys, zs)).T rxs, rys, rzs = field.evaluate_grid(xs, ys, zs) vectors = np.stack((rxs, rys, rzs)).T if self.auto_scale: norms = np.linalg.norm(vectors, axis=1) max_norm = norms.max() size = b2n - b1n size_x = size[0] / samples_x size_y = size[1] / samples_y size_z = size[2] / samples_z size = math.pow(size_x * size_y * size_z, 1.0 / 3.0) scale = scale * size / max_norm new_verts, new_edges = self.generate(points, vectors, scale) if self.join: new_verts, new_edges, _ = mesh_join(new_verts, new_edges, [[]] * len(new_verts)) verts_out.append(new_verts) edges_out.append(new_edges) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out)
def copy_object_and_transform_py( vertices: PyVertices, edges: PyEdges, faces: PyFaces, matrices: List[Matrix]) -> Tuple[PyVertices, PyEdges, PyFaces]: # Get mesh and list of matrices # Each matrices create copy of given mesh and transform it meshes: List[Tuple[PyVertices, PyEdges, PyFaces]] = [] for matrix in matrices: new_verts = [(matrix @ Vector(v))[:] for v in vertices] meshes.append((new_verts, edges, faces)) return mesh_join(*list(zip(*meshes)))
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() clipping_s = self.inputs['Clipping'].sv_get() verts_out = [] edges_out = [] faces_out = [] for sites, clipping in zip_long_repeat(vertices_s, clipping_s): if isinstance(clipping, (list, tuple)): clipping = clipping[0] diagram = Voronoi(sites) if self.do_clip: bounds = self.calc_bounds(sites, clipping) if self.out_mode == 'RIDGES': new_verts = diagram.vertices.tolist() new_faces = [e for e in diagram.ridge_vertices if not -1 in e] new_edges = polygons_to_edges([new_faces], True)[0] if self.join: if self.do_clip: new_verts, new_edges, new_faces = self.clip_mesh(bounds, new_verts, new_edges, new_faces, fill=False) verts_out.append(new_verts) edges_out.append(new_edges) faces_out.append(new_faces) else: new_verts, new_edges, new_faces = self.split_ridges(new_verts, new_edges, new_faces) if self.do_clip: new_verts, new_edges, new_faces = self.clip_mesh(bounds, new_verts, new_edges, new_faces, fill=False, iterate=True) verts_out.extend(new_verts) edges_out.extend(new_edges) faces_out.extend(new_faces) else: # REGIONS new_verts, new_edges, new_faces = self.make_regions(diagram) if self.join: new_verts, new_edges, new_faces = mesh_join(new_verts, new_edges, new_faces) new_verts = [new_verts] new_edges = [new_edges] new_faces = [new_faces] if self.do_clip: new_verts, new_edges, new_faces = self.clip_mesh(bounds, new_verts, new_edges, new_faces, fill=True) verts_out.extend(new_verts) edges_out.extend(new_edges) faces_out.extend(new_faces) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) self.outputs['Faces'].sv_set(faces_out)
def process(self): Vertices, PolyEdge = self.inputs Vertices_out, PolyEdge_out = self.outputs if Vertices.is_linked: verts = Vertices.sv_get() poly_edge = PolyEdge.sv_get(default=[[]]) verts_out, _, poly_edge_out = mesh_join(verts, [], poly_edge) if Vertices_out.is_linked: Vertices_out.sv_set([verts_out]) if PolyEdge_out.is_linked: PolyEdge_out.sv_set([poly_edge_out])
def process(self): if 'Vertices' in self.inputs and self.inputs['Vertices'].is_linked and \ 'PolyEdge' in self.inputs and self.inputs['PolyEdge'].is_linked: verts = self.inputs['Vertices'].sv_get() poly_edge = self.inputs['PolyEdge'].sv_get() verts_out, dummy, poly_edge_out = mesh_join(verts, [], poly_edge) if 'Vertices' in self.outputs and self.outputs['Vertices'].is_linked: self.outputs['Vertices'].sv_set([verts_out]) if 'PolyEdge' in self.outputs and self.outputs['PolyEdge'].is_linked: self.outputs['PolyEdge'].sv_set([poly_edge_out])
def process(self): Vertices, PolyEdge = self.inputs Vertices_out, PolyEdge_out = self.outputs if Vertices.is_linked: verts = Vertices.sv_get() poly_edge = PolyEdge.sv_get(default=[[]]) if PolyEdge.is_linked: verts_out, _, poly_edge_out = mesh_join(verts, [], poly_edge) PolyEdge_out.sv_set([poly_edge_out]) else: verts_out = [] _ = [verts_out.extend(vlist) for vlist in verts] Vertices_out.sv_set([verts_out])
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() step_s = self.inputs['Step'].sv_get() fields_s = self.inputs['Field'].sv_get() iterations_s = self.inputs['Iterations'].sv_get() vertices_s = ensure_nesting_level(vertices_s, 4) step_s = ensure_nesting_level(step_s, 2) verts_out = [] edges_out = [] for fields, vertices_l, steps_l, iterations_l in zip_long_repeat(fields_s, vertices_s, step_s, iterations_s): if not isinstance(iterations_l, (list, tuple)): iterations_l = [iterations_l] if not isinstance(steps_l, (list, tuple)): steps_l = [steps_l] if not isinstance(fields, (list, tuple)): fields = [fields] field_verts = [] field_edges = [] for field, vertices, step, iterations in zip_long_repeat(fields, vertices_l, steps_l, iterations_l): if len(vertices) == 0: new_verts = [] new_edges = [] else: new_verts = self.generate_all(field, np.array(vertices), step, iterations) new_edges = [[(i,i+1) for i in range(iterations-1)]] * len(vertices) if self.join: new_verts, new_edges, _ = mesh_join(new_verts, new_edges, [[]] * len(new_verts)) if self.join: field_verts.append(new_verts) field_edges.append(new_edges) else: field_verts.extend(new_verts) field_edges.extend(new_edges) verts_out.extend(field_verts) edges_out.extend(field_edges) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out)
def make_curves(self, curves, samples_t): all_verts = [] all_edges = [] all_faces = [] for curve in curves: t_min, t_max = curve.get_u_bounds() ts = np.linspace(t_min, t_max, num=samples_t) verts = curve.evaluate_array(ts).tolist() n = len(ts) edges = [[i, i + 1] for i in range(n - 1)] edges.append([n - 1, 0]) faces = [list(range(n))] all_verts.append(verts) all_edges.append(edges) all_faces.append(faces) verts, edges, faces = mesh_join(all_verts, all_edges, all_faces) return verts, edges, faces
def apply_and_join_python(vertices, edges, faces, matrices, do_join): n = len(matrices) out_verts = [] if isinstance(vertices[0], np.ndarray): py_verts = [v.tolist() for v in vertices] else: py_verts = vertices apply_matrix_to_vectors(py_verts, matrices, out_verts) if do_join: out_edges = (edges * n)[:n] out_faces = (faces * n)[:n] out_verts, out_edges, out_faces = mesh_join(out_verts, out_edges, out_faces) out_verts, out_edges, out_faces = [out_verts], [out_edges], [out_faces] else: out_edges = (edges * n)[:n] out_faces = (faces * n)[:n] return out_verts, out_edges, out_faces
def random_subdiv_mesh(verts_m, pols_m, iteration, field): verts, faces = [], [] for pol in pols_m: verts_out, faces_out = [], [] new_quad = faces_out.append pts = sort(verts_m, pol) print(field.evaluate(*get_center(pts))) if field.evaluate(*get_center(pts)) > subdiv_threshold: #if random.random()>subdiv_probability: X = 0.5 +(random.random() - 0.5) * random_factor Y = 0.5 +(random.random() - 0.5) * random_factor pos_a = lerp(pts[0], pts[1], Y) pos_b = lerp(pts[1], pts[2], X) pos_c = lerp(pts[3], pts[2], 1-Y) pos_d = lerp(pts[0], pts[3], X) pos_e = lerp(pos_d, pos_b, Y) pos_f = lerp(pos_d, pos_b, 1-Y) # indices = 0, 1, 2, 3 verts_out.extend(pts) # indices = 4, 5, 6, 7, 8, 9 verts_out.extend([pos_a, pos_b, pos_c, pos_d, pos_e, pos_f]) new_quad([0, 4, 8, 7]) new_quad([4, 1, 5, 8]) new_quad([5, 2, 6, 9]) new_quad([7, 9, 6, 3]) else: verts_out.extend(pts) new_quad([0, 1, 2, 3]) faces.append(faces_out) verts.append(verts_out) verts, _, faces = mesh_join(verts, [], faces) if iteration < 2: return verts, faces else: return random_subdiv_mesh(verts, faces, iteration - 1, field)
def process(self): if not self.inputs['Matrices'].is_linked: return vertices = self.inputs['Vertices'].sv_get() matrices = self.inputs['Matrices'].sv_get() matrices = Matrix_generate(matrices) n = len(matrices) result_vertices = (vertices*n)[:n] outV = [] for i, i2 in zip(matrices, result_vertices): outV.append([(i*Vector(v))[:] for v in i2]) edges = self.inputs['Edges'].sv_get(default=[[]]) faces = self.inputs['Faces'].sv_get(default=[[]]) result_edges = (edges * n)[:n] result_faces = (faces * n)[:n] if self.do_join: outV, result_edges, result_faces = mesh_join(outV, result_edges, result_faces) outV, result_edges, result_faces = [outV], [result_edges], [result_faces] self.outputs['Edges'].sv_set(result_edges) self.outputs['Faces'].sv_set(result_faces) self.outputs['Vertices'].sv_set(outV)
def generate_tiles(radius, angle, separate, gridList): verts, edges, polys = circle(radius, radians(30 - angle), 6, None, 'pydata') vertGridList, edgeGridList, polyGridList = [[], [], []] for grid in gridList: vertList, edgeList, polyList = [[], [], []] addVert, addEdge, addPoly = [vertList.append, edgeList.append, polyList.append] for cx, cy, _ in grid: verts2 = [(x + cx, y + cy, 0.0) for x, y, _ in verts] addVert(verts2) addEdge(edges) addPoly(polys) if not separate: vertList, edgeList, polyList = mesh_join(vertList, edgeList, polyList) vertGridList.append(vertList) edgeGridList.append(edgeList) polyGridList.append(polyList) return vertGridList, edgeGridList, polyGridList
def process(self): if not any(socket.is_linked for socket in self.outputs): return verts_in = self.inputs['Vertices'].sv_get(deepcopy=False) faces_in = self.inputs['Faces'].sv_get(deepcopy=False) sites_in = self.inputs['Sites'].sv_get(deepcopy=False) #thickness_in = self.inputs['Thickness'].sv_get() spacing_in = self.inputs['Spacing'].sv_get(deepcopy=False) verts_in = ensure_nesting_level(verts_in, 4) input_level = get_data_nesting_level(sites_in) sites_in = ensure_nesting_level(sites_in, 4) faces_in = ensure_nesting_level(faces_in, 4) #thickness_in = ensure_nesting_level(thickness_in, 2) spacing_in = ensure_nesting_level(spacing_in, 2) nested_output = input_level > 3 precision = 10 ** (-self.accuracy) verts_out = [] edges_out = [] faces_out = [] sites_out = [] for params in zip_long_repeat(verts_in, faces_in, sites_in, spacing_in): new_verts = [] new_edges = [] new_faces = [] new_sites = [] for verts, faces, sites, spacing in zip_long_repeat(*params): verts, edges, faces, sites = voronoi_on_mesh(verts, faces, sites, thickness=0, spacing = spacing, #clip_inner = self.clip_inner, clip_outer = self.clip_outer, do_clip=True, clipping=None, mode = self.mode, precision = precision) if self.mode == 'VOLUME' and self.normals: verts, edges, faces = recalc_normals(verts, edges, faces, loop=True) if self.join_mode == 'FLAT': new_verts.extend(verts) new_edges.extend(edges) new_faces.extend(faces) new_sites.extend(sites) elif self.join_mode == 'SEPARATE': new_verts.append(verts) new_edges.append(edges) new_faces.append(faces) new_sites.append(sites) else: # JOIN verts, edges, faces = mesh_join(verts, edges, faces) new_verts.append(verts) new_edges.append(edges) new_faces.append(faces) new_sites.append(sites) if nested_output: verts_out.append(new_verts) edges_out.append(new_edges) faces_out.append(new_faces) sites_out.append(new_sites) else: verts_out.extend(new_verts) edges_out.extend(new_edges) faces_out.extend(new_faces) sites_out.extend(new_sites) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) self.outputs['Faces'].sv_set(faces_out)
working_geom = bmesh_from_pydata(obj_verts_in, None, obj_faces_in, normal_update=True) for pt, normal in v: geom_in = working_geom.verts[:] + working_geom.edges[:] + working_geom.faces[:] res = bmesh.ops.bisect_plane(working_geom, geom=geom_in, dist=0.00001, plane_co=pt, plane_no=normal, use_snap_center=False, clear_outer=True, clear_inner=False) surround = [ e for e in res['geom_cut'] if isinstance(e, bmesh.types.BMEdge) ] fres = bmesh.ops.edgenet_prepare(working_geom, edges=surround) bmesh.ops.edgeloop_fill(working_geom, edges=fres['edges']) ___v, _, ___f = pydata_from_bmesh(working_geom) __new_verts.append(___v) __new_faces.append(___f) _v, _e, _f = mesh_join(__new_verts, [], __new_faces) new_verts.append(_v) new_faces.append(_f)
def get_filled_graph(data_in): #Sub_object is also object but divded from start object sub_verts = [] sub_edges = [] verts_out = [] polys_out = [] #Cleaning snd separating mesh for v_obj, e_obj in zip(*data_in): outer_poly, used_edges_mask, neighbours = get_outer_poly(v_obj, e_obj) #Checking bridg edges if 2 in used_edges_mask.values(): #Del bridg edges len_edges = len(e_obj) for i, edg in enumerate(reversed(e_obj)): if used_edges_mask[tuple(edg)] == 2: del e_obj[len_edges - 1 - i] #Del loose verts v_obj, e_obj = del_loose(v_obj, e_obj) #Dived loos parts if v_obj: v_obj, e_obj = separate_loos(v_obj, e_obj) sub_verts.extend(v_obj) sub_edges.extend(e_obj) #del empty objects sub_objects = [[v_obj, e_obj] for v_obj, e_obj in zip(sub_verts, sub_edges) if v_obj] for v_obj, e_obj in sub_objects: #serch outer poly again outer_poly, used_edges_mask, neighbours = get_outer_poly(v_obj, e_obj) #filling graph steck = [[i1, i2] for i1, i2 in zip(outer_poly, outer_poly[1:] + [outer_poly[0]])] polys = [] while steck: poly, used_edges = bypass_edges(steck[-1][1], steck[-1][0], neighbours) polys.append(poly) used_edges_mask = create_mask_used_edges(used_edges_mask, used_edges) del steck[-1] #Add new edg in steck for edg in used_edges: real_edg = edg if tuple(edg) not in used_edges_mask: edg = list(reversed(edg)) if used_edges_mask[tuple(edg)] < 2: steck.append(real_edg) #Check useing edges in steck len_steck = len(steck) for i, edg in enumerate(reversed(steck)): real_edg = edg if tuple(edg) not in used_edges_mask: edg = list(reversed(edg)) if used_edges_mask[tuple(edg)] >= 2: del steck[len_steck - 1 - i] verts_out.append([[*v[:], 0] for v in v_obj]) polys_out.append(polys) verts_out, _, polys_out = mesh_join(verts_out, [], polys_out) return verts_out, polys_out
def process(self): if not any(socket.is_linked for socket in self.outputs): return field_s = self.inputs['Field'].sv_get() bounds_s = self.inputs['Bounds'].sv_get() samples_xy_s = self.inputs['SamplesXY'].sv_get() samples_z_s = self.inputs['SamplesZ'].sv_get() samples_value_s = self.inputs['ValueSamples'].sv_get() verts_out = [] edges_out = [] faces_out = [] inputs = zip_long_repeat(field_s, bounds_s, samples_xy_s, samples_z_s, samples_value_s) for field, bounds, samples_xy, samples_z, samples_value in inputs: if isinstance(samples_xy, (list, tuple)): samples_xy = samples_xy[0] if isinstance(samples_z, (list, tuple)): samples_z = samples_z[0] if isinstance(samples_value, (list, tuple)): samples_value = samples_value[0] b1, b2 = self.get_bounds(bounds) min_x, max_x = b1[0], b2[0] min_y, max_y = b1[1], b2[1] min_z, max_z = b1[2], b2[2] x_size = (max_x - min_x) / samples_xy y_size = (max_y - min_y) / samples_xy x_range = np.linspace(min_x, max_x, num=samples_xy) y_range = np.linspace(min_y, max_y, num=samples_xy) z_range = np.linspace(min_z, max_z, num=samples_z) xs, ys, zs = np.meshgrid(x_range, y_range, z_range, indexing='ij') xs, ys, zs = xs.flatten(), ys.flatten(), zs.flatten() field_values = field.evaluate_grid(xs, ys, zs) min_field = field_values.min() max_field = field_values.max() field_values = field_values.reshape( (samples_xy, samples_xy, samples_z)) field_stops = np.linspace(min_field, max_field, num=samples_value) new_verts = [] new_edges = [] new_faces = [] for i in range(samples_z): z_value = zs[i] z_verts = [] z_edges = [] z_faces = [] for j in range(samples_value): value = field_stops[j] contours = measure.find_contours(field_values[:, :, i], level=value) value_verts, value_edges, value_faces = make_contours( samples_xy, samples_xy, min_x, x_size, min_y, y_size, z_value, contours, make_faces=self.make_faces, connect_bounds=self.connect_bounds) if value_verts: z_verts.extend(value_verts) z_edges.extend(value_edges) z_faces.extend(value_faces) new_verts.extend(z_verts) new_edges.extend(z_edges) new_faces.extend(z_faces) if self.join: new_verts, new_edges, new_faces = mesh_join( new_verts, new_edges, new_faces) verts_out.append(new_verts) edges_out.append(new_edges) faces_out.append(new_faces) else: verts_out.extend(new_verts) edges_out.extend(new_edges) faces_out.extend(new_faces) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) self.outputs['Faces'].sv_set(faces_out)
def get_filled_graph(data_in): #Sub_object is also object but divded from start object sub_verts = [] sub_edges = [] verts_out = [] polys_out = [] #Cleaning snd separating mesh for v_obj, e_obj in zip(*data_in): outer_poly, used_edges_mask, neighbours = get_outer_poly(v_obj, e_obj) #Checking bridg edges if 2 in used_edges_mask.values(): #Del bridg edges len_edges = len(e_obj) for i,edg in enumerate(reversed(e_obj)): if used_edges_mask[tuple(edg)] == 2: del e_obj[len_edges - 1 - i] #Del loose verts v_obj, e_obj = del_loose(v_obj, e_obj) #Dived loos parts if v_obj: v_obj, e_obj = separate_loos(v_obj,e_obj) sub_verts.extend(v_obj) sub_edges.extend(e_obj) #del empty objects sub_objects = [[v_obj, e_obj] for v_obj, e_obj in zip(sub_verts,sub_edges) if v_obj] for v_obj, e_obj in sub_objects: #serch outer poly again outer_poly, used_edges_mask, neighbours = get_outer_poly(v_obj, e_obj) #filling graph steck = [[i1,i2] for i1,i2 in zip(outer_poly,outer_poly[1:] + [outer_poly[0]])] polys = [] while steck: poly, used_edges = bypass_edges(steck[-1][1],steck[-1][0],neighbours) polys.append(poly) used_edges_mask = create_mask_used_edges(used_edges_mask, used_edges) del steck[-1] #Add new edg in steck for edg in used_edges: real_edg = edg if tuple(edg) not in used_edges_mask: edg = list(reversed(edg)) if used_edges_mask[tuple(edg)] < 2: steck.append(real_edg) #Check useing edges in steck len_steck = len(steck) for i,edg in enumerate(reversed(steck)): real_edg = edg if tuple(edg) not in used_edges_mask: edg = list(reversed(edg)) if used_edges_mask[tuple(edg)] >= 2: del steck[len_steck - 1 - i] verts_out.append([[*v[:],0] for v in v_obj]) polys_out.append(polys) verts_out, _, polys_out = mesh_join(verts_out,[], polys_out) return verts_out, polys_out
def process(self): self.handle_attr_socket() if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) callback_disable(n_id) if not any( [self.display_verts, self.display_edges, self.display_faces]): return verts_socket, edges_socket, faces_socket, matrix_socket = self.inputs[: 4] if verts_socket.is_linked: display_faces = self.display_faces and faces_socket.is_linked display_edges = self.display_edges and (edges_socket.is_linked or faces_socket.is_linked) config = self.fill_config() data = self.get_data() coords, edge_indices, face_indices = mesh_join( data[0], data[1], data[2]) geom = lambda: None geom.verts = coords if self.display_verts and not any([display_edges, display_faces]): draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_verts, 'args': (geom, config) } callback_enable(n_id, draw_data) return if edges_socket.is_linked and not faces_socket.is_linked: if self.use_dashed: self.add_gl_stuff_to_config(config) geom.edges = edge_indices draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_edges, 'args': (geom, config) } callback_enable(n_id, draw_data) return if faces_socket.is_linked: # we could offer different optimizations, like # -expecting only tris as input, then no processing # -expecting only quads, then minimal processing needed # -expecting mixed bag, then ensure_triangles (current default) if self.display_faces: geom.faces = ensure_triangles(coords, face_indices) if self.display_edges: if self.use_dashed: self.add_gl_stuff_to_config(config) # we don't want to draw the inner edges of triangulated faces; use original face_indices. # pass edges from socket if we can, else we manually compute them from faces geom.edges = edge_indices if edges_socket.is_linked else edges_from_faces( face_indices) if self.display_faces: self.faces_diplay(geom, config) draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_faces, 'args': (geom, config) } callback_enable(n_id, draw_data) return return elif matrix_socket.is_linked: matrices = matrix_socket.sv_get(deepcopy=False, default=[Matrix()]) draw_data = { 'tree_name': self.id_data.name[:], 'custom_function': draw_matrix, 'args': (matrices, ) } callback_enable(n_id, draw_data)
def process(self): if not any(socket.is_linked for socket in self.outputs): return fields_s = self.inputs['Field'].sv_get() surface_s = self.inputs['Surface'].sv_get() samples_u_s = self.inputs['SamplesU'].sv_get() samples_v_s = self.inputs['SamplesV'].sv_get() value_s = self.inputs['Value'].sv_get() fields_s = ensure_nesting_level(fields_s, 2, data_types=(SvScalarField, )) surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface, )) samples_u_s = ensure_nesting_level(samples_u_s, 2) samples_v_s = ensure_nesting_level(samples_v_s, 2) value_s = ensure_nesting_level(value_s, 2) verts_out = [] edges_out = [] uv_verts_out = [] for field_i, surface_i, samples_u_i, samples_v_i, value_i in zip_long_repeat( fields_s, surface_s, samples_u_s, samples_v_s, value_s): for field, surface, samples_u, samples_v, value in zip_long_repeat( field_i, surface_i, samples_u_i, samples_v_i, value_i): surface_verts = [] surface_uv = [] surface_edges = [] u_min, u_max = surface.get_u_min(), surface.get_u_max() v_min, v_max = surface.get_v_min(), surface.get_v_max() u_range = np.linspace(u_min, u_max, num=samples_u) v_range = np.linspace(v_min, v_max, num=samples_v) us, vs = np.meshgrid(u_range, v_range, indexing='ij') us, vs = us.flatten(), vs.flatten() surface_points = surface.evaluate_array(us, vs) xs = surface_points[:, 0] ys = surface_points[:, 1] zs = surface_points[:, 2] field_values = field.evaluate_grid(xs, ys, zs) field_values = field_values.reshape((samples_u, samples_v)) contours = measure.find_contours(field_values, level=value) u_size = (u_max - u_min) / samples_u v_size = (v_max - v_min) / samples_v uv_contours, new_edges, _ = make_contours( samples_u, samples_v, u_min, u_size, v_min, v_size, 0, contours, make_faces=True, connect_bounds=self.connect_bounds) if uv_contours: for uv_points in uv_contours: us = np.array([p[0] for p in uv_points]) vs = np.array([p[1] for p in uv_points]) new_verts = surface.evaluate_array(us, vs).tolist() surface_uv.append(uv_points) surface_verts.append(new_verts) surface_edges.extend(new_edges) if self.join: surface_verts, surface_edges, _ = mesh_join( surface_verts, surface_edges, [[]] * len(surface_edges)) surface_uv = sum(surface_uv, []) verts_out.append(surface_verts) uv_verts_out.append(surface_uv) edges_out.append(surface_edges) else: verts_out.append([]) uv_verts_out.append([]) edges_out.append([]) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) if 'UVVertices' in self.outputs: self.outputs['UVVertices'].sv_set(uv_verts_out)
def process(self): self.handle_attr_socket() if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) callback_disable(n_id) if not any( [self.display_verts, self.display_edges, self.display_faces]): return verts_socket, edges_socket, faces_socket, matrix_socket = self.inputs[: 4] if verts_socket.is_linked: display_faces = self.display_faces and faces_socket.is_linked display_edges = self.display_edges and (edges_socket.is_linked or faces_socket.is_linked) config = self.fill_config() data = self.get_data() if len(data[0]) > 1: coords, edge_indices, face_indices = mesh_join( data[0], data[1], data[2]) if not coords: return elif len(data[0][0]) > 0: coords, edge_indices, face_indices = [ d[0].tolist() if type(d[0]) == ndarray else d[0] for d in data[:3] ] else: return geom = lambda: None geom.verts = coords if self.display_verts and not any([display_edges, display_faces]): gl_instructions = self.format_draw_data(func=draw_verts, args=(geom, config)) callback_enable(n_id, gl_instructions) return if edges_socket.is_linked and not faces_socket.is_linked: if self.use_dashed: self.add_gl_stuff_to_config(config) geom.edges = edge_indices gl_instructions = self.format_draw_data(func=draw_edges, args=(geom, config)) callback_enable(n_id, gl_instructions) return if faces_socket.is_linked: # expecting mixed bag of tris/quads/ngons if self.display_faces: geom.faces = ensure_triangles(coords, face_indices, self.handle_concave_quads) if self.display_edges: if self.use_dashed: self.add_gl_stuff_to_config(config) # we don't want to draw the inner edges of triangulated faces; use original face_indices. # pass edges from socket if we can, else we manually compute them from faces geom.edges = edge_indices if edges_socket.is_linked else edges_from_faces( face_indices) if self.display_faces: self.faces_diplay(geom, config) gl_instructions = self.format_draw_data(func=draw_complex, args=(geom, config)) callback_enable(n_id, gl_instructions) return return elif matrix_socket.is_linked: matrices = matrix_socket.sv_get(deepcopy=False, default=[Matrix()]) gl_instructions = self.format_draw_data(func=draw_matrix, args=(matrices, )) callback_enable(n_id, gl_instructions)
def process(self): if not any(output.is_linked for output in self.outputs): return verts_recpt_s = self.inputs['VersR'].sv_get(deepcopy=False) faces_recpt_s = self.inputs['PolsR'].sv_get(default=[[]], deepcopy=False) verts_donor_s = self.inputs['VersD'].sv_get() faces_donor_s = self.inputs['PolsD'].sv_get() if 'FaceDataD' in self.inputs: face_data_donor_s = self.inputs['FaceDataD'].sv_get(default=[[]]) else: face_data_donor_s = [[]] zcoefs_s = self.inputs['Z_Coef'].sv_get(deepcopy=False) zoffsets_s = self.inputs['Z_Offset'].sv_get(deepcopy=False) zrotations_s = self.inputs['Z_Rotation'].sv_get(deepcopy=False) wcoefs_s = self.inputs['W_Coef'].sv_get(deepcopy=False) if 'FrameWidth' in self.inputs: frame_widths_s = self.inputs['FrameWidth'].sv_get(deepcopy=True) else: frame_widths_s = [[0.5]] if 'PolyRotation' in self.inputs: facerots_s = self.inputs['PolyRotation'].sv_get(default = [[0]], deepcopy=False) else: facerots_s = [[0]] mask_s = self.inputs['PolyMask'].sv_get(default = [[1]], deepcopy=False) if 'Threshold' in self.inputs: thresholds_s = self.inputs['Threshold'].sv_get() else: thresholds_s = [[self.threshold]] output = OutputData() if self.matching_mode == 'PERFACE': verts_donor_s = [verts_donor_s] faces_donor_s = [faces_donor_s] face_data_donor_s = [face_data_donor_s] #self.info("FW: %s", frame_widths_s) #frame_widths_s = [frame_widths_s] objects = match_long_repeat([verts_recpt_s, faces_recpt_s, verts_donor_s, faces_donor_s, face_data_donor_s, frame_widths_s, zcoefs_s, zoffsets_s, zrotations_s, wcoefs_s, facerots_s, mask_s, thresholds_s]) #self.info("N objects: %s", len(list(zip(*objects)))) for verts_recpt, faces_recpt, verts_donor, faces_donor, face_data_donor, frame_widths, zcoefs, zoffsets, zrotations, wcoefs, facerots, mask, threshold in zip(*objects): n_faces_recpt = len(faces_recpt) fullList(zcoefs, n_faces_recpt) fullList(zoffsets, n_faces_recpt) fullList(zrotations, n_faces_recpt) if get_data_nesting_level(frame_widths) < 1: frame_widths = [frame_widths] fullList(frame_widths, n_faces_recpt) fullList(wcoefs, n_faces_recpt) fullList(facerots, n_faces_recpt) mask = cycle_for_length(mask, n_faces_recpt) if isinstance(threshold, (list, tuple)): threshold = threshold[0] new = self._process(verts_recpt, faces_recpt, verts_donor, faces_donor, face_data_donor, frame_widths, zcoefs, zoffsets, zrotations, wcoefs, facerots, mask) output.verts_out.extend(new.verts_out) output.faces_out.extend(new.faces_out) output.face_data_out.extend(new.face_data_out) output.vert_recpt_idx_out.extend(new.vert_recpt_idx_out) output.face_recpt_idx_out.extend(new.face_recpt_idx_out) output.verts_out = Vector_degenerate(output.verts_out) if self.join: output.verts_out, _, output.faces_out = mesh_join(output.verts_out, [], output.faces_out) output.face_data_out = sum(output.face_data_out, []) output.vert_recpt_idx_out = sum(output.vert_recpt_idx_out, []) output.face_recpt_idx_out = sum(output.face_recpt_idx_out, []) if self.remove_doubles: doubles_res = remove_doubles(output.verts_out, [], output.faces_out, threshold, face_data=output.face_data_out, vert_data=output.vert_recpt_idx_out) if len(doubles_res) == 4: output.verts_out, _, output.faces_out, data_out = doubles_res else: output.verts_out, _, output.faces_out = doubles_res data_out = dict() output.vert_recpt_idx_out = data_out.get('verts', []) if output.face_recpt_idx_out: output.face_recpt_idx_out = [output.face_recpt_idx_out[idx] for idx in data_out['face_init_index']] output.verts_out = [output.verts_out] output.faces_out = [output.faces_out] output.face_data_out = [output.face_data_out] output.vert_recpt_idx_out = [output.vert_recpt_idx_out] output.face_recpt_idx_out = [output.face_recpt_idx_out] self.outputs['Vertices'].sv_set(output.verts_out) self.outputs['Polygons'].sv_set(output.faces_out) if 'FaceData' in self.outputs: self.outputs['FaceData'].sv_set(output.face_data_out) if 'VertRecptIdx' in self.outputs: self.outputs['VertRecptIdx'].sv_set(output.vert_recpt_idx_out) if 'FaceRecptIdx' in self.outputs: self.outputs['FaceRecptIdx'].sv_set(output.face_recpt_idx_out)
def process(self): if not self.is_active: return verts = self.inputs['vertices'].sv_get(deepcopy=False, default=[]) edges = self.inputs['edges'].sv_get(deepcopy=False, default=[[]]) faces = self.inputs['faces'].sv_get(deepcopy=False, default=[[]]) mat_indexes = self.inputs['material_idx'].sv_get(deepcopy=False, default=[[]]) matrices = self.inputs['matrix'].sv_get(deepcopy=False, default=[]) # first step is merge everything if the option if self.is_merge: if matrices: objects_number = max([len(verts), len(matrices)]) mat_indexes = [[ i for _, obj, mat_i in zip(range( objects_number), cycle(faces), cycle(mat_indexes)) for f, i in zip(obj, cycle(mat_i)) ]] _, *join_mesh_data = list( zip(*zip(range(objects_number), cycle(verts), cycle(edges), cycle(faces), cycle(matrices)))) verts, edges, faces = apply_and_join_python( *join_mesh_data, True) matrices = [] else: mat_indexes = [[ i for obj, mat_i in zip(faces, cycle(mat_indexes)) for f, i in zip(obj, cycle(mat_i)) ]] verts, edges, faces = mesh_join(verts, edges if edges[0] else [], faces) # function has good API verts, edges, faces = [verts], [edges], [faces] objects_number = max([len(verts), len(matrices)]) if verts else 0 # extract mesh matrices if self.apply_matrices_to == 'mesh': if matrices: mesh_matrices = matrices else: mesh_matrices = cycle([None]) else: mesh_matrices = cycle([None]) # extract object matrices if self.apply_matrices_to == 'object': if matrices: obj_matrices = matrices else: if self.is_lock_origin: obj_matrices = cycle([Matrix.Identity(4)]) else: obj_matrices = [] else: if self.is_lock_origin: obj_matrices = cycle([Matrix.Identity(4)]) else: obj_matrices = [] # regenerate mesh data blocks correct_collection_length(self.mesh_data, objects_number) create_mesh_data = zip(self.mesh_data, cycle(verts), cycle(edges), cycle(faces), cycle(mesh_matrices), cycle(mat_indexes)) for me_data, v, e, f, m, mat_i in create_mesh_data: me_data.regenerate_mesh(self.base_data_name, v, e, f, m, self.fast_mesh_update) if self.material: me_data.mesh.materials.clear() me_data.mesh.materials.append(self.material) if mat_indexes: mat_i = [ mi for _, mi in zip(me_data.mesh.polygons, cycle(mat_i)) ] me_data.mesh.polygons.foreach_set('material_index', mat_i) me_data.set_smooth(self.is_smooth_mesh) # regenerate object data blocks self.regenerate_objects([self.base_data_name], [d.mesh for d in self.mesh_data], [self.collection]) [ setattr(prop.obj, 'matrix_local', m) for prop, m in zip(self.object_data, cycle(obj_matrices)) ] [ setattr(prop.obj, 'show_wire', self.show_wireframe) for prop in self.object_data ] self.outputs['Objects'].sv_set( [obj_data.obj for obj_data in self.object_data])