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_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_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
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)
if quad_verts and quad_faces:
random.seed(seed)
verts, faces = random_subdiv_mesh(quad_verts[0], quad_faces[0], iterations)
verts, edges, faces = remove_doubles(verts, [], faces, 1e-5)
verts = [verts]
edges = [edges]
faces = [faces]
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 any(s.is_linked for s in self.outputs):
return
verts_in = self.inputs['Vertices'].sv_get()
edges_in = self.inputs['Edges'].sv_get()
offset_in = self.inputs['Offset'].sv_get()
step_in = self.inputs['Step'].sv_get()
n_connections_in = self.inputs['NConnections'].sv_get()
max_rhos_in = self.inputs['MaxRho'].sv_get()
count_in = self.inputs['Count'].sv_get()
length_in = self.inputs['Length'].sv_get()
if self.z_mode == 'CURVE':
curves_in = self.inputs['Curve'].sv_get()
else:
curves_in = [[]]
verts_out = []
edges_out = []
faces_out = []
Z = self.get_orientation_vector()
if self.z_mode == 'AXIS':
z_idx = 'XYZ'.index(self.orient_axis)
else:
z_idx = None
objects = match_long_repeat([
verts_in, edges_in, offset_in, step_in, n_connections_in,
max_rhos_in, count_in, length_in, curves_in
])
for verts, edges, offsets, steps, n_connections, max_rhos, counts, lengths, curves in zip(
*objects):
nverts = len(verts)
offsets = cycle_for_length(offsets, nverts)
steps = cycle_for_length(steps, nverts)
n_connections = cycle_for_length(n_connections, nverts)
max_rhos = cycle_for_length(max_rhos, nverts)
if self.len_mode == 'COUNT':
counts = cycle_for_length(counts, nverts)
lengths = [None for i in range(nverts)]
else:
counts = [None for i in range(nverts)]
lengths = cycle_for_length(lengths, nverts)
if curves:
curves = cycle_for_length(curves, nverts)
bm = bmesh.new()
bm.verts.ensure_lookup_table()
verts_bm = []
for i, v in enumerate(verts):
if self.z_mode == 'AXIS':
verts_line = make_verts_axis(v, Z, self.make_basis,
steps[i] * offsets[i],
steps[i], counts[i],
lengths[i])
else:
verts_line = make_verts_curve(v, curves[i])
verts_line_bm = []
prev_bm_vert = None
new_vert = bm.verts.new
new_edge = bm.edges.new
for v in verts_line:
bm_vert = new_vert(v)
verts_line_bm.append(bm_vert)
bm.verts.ensure_lookup_table()
if prev_bm_vert is not None:
new_edge((prev_bm_vert, bm_vert))
prev_bm_vert = bm_vert
verts_bm.append(verts_line_bm)
for i, j in edges:
process_edge(bm, z_idx, verts_bm[i], verts_bm[j], steps[i],
steps[j], n_connections[i], n_connections[j],
max_rhos[i], max_rhos[j])
verts_new, edges_new, _ = pydata_from_bmesh(bm)
bm.free()
verts_new, edges_new = intersect_edges_3d(verts_new, edges_new,
1e-3)
verts_new, edges_new, _ = remove_doubles(verts_new, edges_new, [],
1e-3)
if self.outputs['Faces'].is_linked:
bm = bmesh_from_pydata(verts_new,
edges_new, [],
normal_update=True)
if self.z_mode == 'AXIS':
for i, j in edges:
side_edges = []
v_i = Vector(verts[i])
v_j = Vector(verts[j])
#self.info("Check: [%s - %s]", v_i, v_j)
for bm_edge in bm.edges:
bm_v1 = bm_edge.verts[0].co
bm_v2 = bm_edge.verts[1].co
if self.is_same_edge(bm_v1, bm_v2, v_i, v_j):
side_edges.append(bm_edge)
#self.info("Yes: [%s - %s]", bm_v1, bm_v2)
else:
pass
#self.info("No: [%s - %s]", bm_v1, bm_v2)
bmesh.ops.holes_fill(bm, edges=side_edges, sides=4)
bm.edges.ensure_lookup_table()
bm.faces.ensure_lookup_table()
else:
bmesh.ops.holes_fill(bm, edges=bm.edges[:], sides=4)
verts_new, edges_new, faces_new = pydata_from_bmesh(bm)
bm.free()
else:
faces_new = []
verts_out.append(verts_new)
edges_out.append(edges_new)
faces_out.append(faces_new)
self.outputs['Vertices'].sv_set(verts_out)
self.outputs['Edges'].sv_set(edges_out)
self.outputs['Faces'].sv_set(faces_out)
faces_mesh = []
new_faces = faces_mesh.extend
for pol in pols_m:
pts = sort(verts_mesh, pol)
faces_pol = subdivide_face_to_quads(pts, pol, verts_mesh, random_f)
new_faces(faces_pol)
if it < 2:
return verts_mesh, faces_mesh
else:
return subdiv_mesh_to_quads(verts_mesh, faces_mesh, it - 1, random_f)
if verts_in and faces_in:
verts = []
edges = []
faces = []
seed_l = enusure_list(seed)
iterations_l = enusure_list(iterations)
random_fac = enusure_list(random_factor)
for v, f, s, it, r in zip(
*mlr([verts_in, faces_in, seed_l, iterations_l, random_fac])):
random.seed(s)
verts_out, faces_out = subdiv_mesh_to_quads(v, f, min(it, 5), r)
verts_out, edges_out, faces_out = remove_doubles(
verts_out, [], faces_out, 1e-5)
verts.append(verts_out)
edges.append(edges_out)
faces.append(faces_out)
