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):
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])
