def np_rotate_one_center(props, mat):
center = np.array(props[1][0])[np.newaxis, :]
verts = np.array(props[0])
if np.linalg.norm(center[0]) > 0:
return matrix_apply_np(verts - center, mat) + center
return matrix_apply_np(verts, mat)
def preprocess_verts(noise_matrix, verts, numpy_mode):
if isinstance(noise_matrix[0], Matrix):
if numpy_mode:
verts = [
matrix_apply_np(
vs if isinstance(vs, np.ndarray) else np.array(vs),
m.inverted())
for vs, m in zip_long_repeat(verts, noise_matrix)
]
else:
verts = [
matrix_apply_np(
vs if isinstance(vs, np.ndarray) else np.array(vs),
m.inverted()).tolist()
for vs, m in zip_long_repeat(verts, noise_matrix)
]
else:
verts = [[m.inverted() @ Vector(v) for v, m in zip(vs, cycle(ms))] for vs, ms in zip_long_repeat(verts, noise_matrix)]
return verts
def make_verts(size, x_verts, y_verts, z_verts, matrix, origin):
'''creates cube verts, first vertical faces as a roll and after the bottom and top caps'''
size_h = size / 2
if origin == 'CENTER':
offset = [0, 0, 0]
elif origin == 'BOTTOM':
offset = [0, 0, size_h]
else:
offset = [size_h, size_h, size_h]
sidex = np.linspace(-size_h + offset[0], size_h + offset[0], x_verts)
sidey = np.linspace(-size_h + offset[1], size_h + offset[1], y_verts)
sidez = np.linspace(-size_h + offset[2], size_h + offset[2], z_verts)
z_spread = 2 * x_verts + 2 * y_verts - 4
roll = np.zeros((z_spread * z_verts, 3))
row_id = np.arange(z_spread * z_verts) % z_spread
plane_y1 = row_id < y_verts
plane_x1 = np.all((y_verts - 2 < row_id, row_id < y_verts + x_verts - 1),
axis=0)
plane_y2 = np.all(
(y_verts + x_verts - 3 < row_id, row_id < z_spread - x_verts + 2),
axis=0)
plane_x2 = row_id > z_spread - x_verts + 1
roll[:, 2] = np.repeat(sidez, z_spread)
roll[plane_y1, 0] = sidex[0]
roll[plane_y1, 1] = np.repeat(sidey, z_verts).reshape(-1, z_verts).T.flat
roll[plane_x1, 0] = np.repeat(sidex, z_verts).reshape(-1, z_verts).T.flat
roll[plane_x1, 1] = sidey[-1]
roll[plane_y2, 0] = sidex[-1]
roll[plane_y2, 1] = np.repeat(np.flip(sidey),
z_verts).reshape(-1, z_verts).T.flat
roll[plane_x2, 1] = sidey[0]
roll[plane_x2, 0] = np.repeat(np.flip(sidex[1:-1]),
z_verts).reshape(-1, z_verts).T.flat
x_coords, y_coords = np.meshgrid(sidex[1:-1],
sidey[1:-1],
sparse=False,
indexing='xy')
z_coords = np.full(x_coords.shape, -size_h + offset[2])
bottom = np.array([x_coords, y_coords, z_coords]).T.reshape(-1, 3)
top = np.array([x_coords, y_coords, z_coords + size]).T.reshape(-1, 3)
if not matrix == Matrix():
return matrix_apply_np(np.concatenate([roll, bottom, top]), matrix)
return np.concatenate([roll, bottom, top])
def copy_object_and_transform_np(
vertices: np.ndarray, edges: np.ndarray, faces: PyFaces,
matrices: List[Matrix]) -> Tuple[np.ndarray, np.ndarray, PyFaces]:
# Get mesh and list of matrices
# Each matrices create copy of given mesh and transform it
meshes: List[Tuple[np.ndarray, np.ndarray, PyFaces]] = []
for matrix in matrices:
new_verts = matrix_apply_np(vertices, matrix)
meshes.append((new_verts, edges, faces))
return mesh_join_np(*list(zip(*meshes)), False)
def make_verts_grid(sidex, sidey, matrix, direction):
y_coords, x_coords = np.meshgrid(sidey, sidex, sparse=False, indexing='xy')
z_coords = np.full(x_coords.shape, 0.0)
if direction == 'XY':
plane = np.array([x_coords, y_coords, z_coords]).T.reshape(-1, 3)
elif direction == 'YZ':
plane = np.array([z_coords, x_coords, y_coords]).T.reshape(-1, 3)
else:
plane = np.array([y_coords, z_coords, x_coords]).T.reshape(-1, 3)
if not matrix == Matrix():
return matrix_apply_np(plane, matrix)
return plane
def v_normal_numpy(verts, pols, noise_type, n_props, result, output_numpy):
bm = bmesh_from_pydata(verts, [], pols, normal_update=True)
normals = np.array([v.normal for v in bm.verts])
scale, seed, matrix, smooth, interpolate = n_props
noise_function = noise_numpy_types[noise_type][interpolate]
smooth = smooth
np_verts = np.array(verts)
n_v = noise_function(matrix_apply_np(np_verts, matrix), seed, smooth)
if output_numpy:
result.append(np_verts + normals * n_v[:, np.newaxis] * scale)
else:
result.append(
(np_verts + normals * n_v[:, np.newaxis] * scale).tolist())
bm.free()
def v_noise_numpy(verts, _, noise_type, n_props, result, output_numpy):
scale, seed, matrix, smooth, interpolate = n_props
noise_function = noise_numpy_types[noise_type][interpolate]
smooth = smooth
np_verts = np.array(verts)
distorted_v = matrix_apply_np(np_verts, matrix)
n_v = np.stack(
(noise_function(distorted_v, seed,
smooth), noise_function(distorted_v, seed + 1, smooth),
noise_function(distorted_v, seed + 2, smooth))).T
if output_numpy:
result.append(np_verts + (2 * n_v - 1) * scale)
else:
result.append((np_verts + (2 * n_v - 1) * scale).tolist())
def vector_transform(af_verts, transformation, transformation_mode,
iterations, coeff):
if transformation_mode == 'MATRIX':
matrix = transformation
for i in range(iterations):
af_verts += (matrix_apply_np(af_verts, matrix) -
af_verts) * coeff[i % len(coeff)]
elif transformation_mode == 'VECTOR':
offset_verts = numpy_full_list_cycle(np.array(transformation),
af_verts.shape[0])
for i in range(iterations):
af_verts += offset_verts * coeff[i % len(coeff)]
elif transformation_mode == 'VECTOR_FIELD':
for i in range(iterations):
i_coeff = coeff[i % len(coeff)]
xs, ys, zs = transformation.evaluate_grid(
af_verts[:, 0], af_verts[:, 1], af_verts[:, 2])
af_verts[:, 0] += xs * i_coeff
af_verts[:, 1] += ys * i_coeff
af_verts[:, 2] += zs * i_coeff
return af_verts
def apply_matrix_to_vectors_np(vertices, matrices, out_verts):
r_vertices = [np.array(v) for v in vertices]
max_v = len(vertices) - 1
for i, mat in enumerate(matrices):
vert_id = min(i, max_v)
out_verts.append(matrix_apply_np(r_vertices[vert_id], mat))
def apply_matrix(self, matrix) -> NpMesh:
"""It will generate new vertices with given matrix applied"""
self.vertices.data = matrix_apply_np(self.vertices.data, matrix)
return self
def np_rotate_many_centers(props, mat, np_local_match):
verts, centers = np_local_match([np.array(p) for p in props[:2]])
return matrix_apply_np(verts - centers, mat) + centers
def extrude_edges(vertices, edges, faces, edge_mask, face_data, matrices):
if not matrices:
matrices = [Matrix()]
if face_data:
face_data_matched = repeat_last_for_length(face_data, len(faces))
if edge_mask:
edge_mask_matched = repeat_last_for_length(edge_mask, len(edges))
if isinstance(edges, np_ndarray):
if edge_mask:
np_edges = edges[edge_mask_matched]
else:
np_edges = edges
else:
if edge_mask:
np_edges = np_array(edges)[edge_mask_matched]
else:
np_edges = np_array(edges)
if isinstance(vertices, np_ndarray):
np_verts = vertices
else:
np_verts = np_array(vertices)
affeced_verts_idx = np_unique(np_edges)
if len(matrices) == 1:
extruded_verts = matrix_apply_np(np_verts[affeced_verts_idx],
matrices[0])
new_vertices = np_concatenate([np_verts, extruded_verts]).tolist()
else:
extruded_verts = [
m @ Vector(v) for v, m in zip(np_verts[affeced_verts_idx].tolist(),
cycle(matrices))
]
new_vertices = vertices + extruded_verts
top_edges = np_edges + len(vertices)
mid_edges = np_zeros((len(affeced_verts_idx), 2), dtype=int)
mid_edges[:, 0] = affeced_verts_idx
mid_edges[:, 1] = affeced_verts_idx + len(vertices)
extruded_edges_py = (np_concatenate([top_edges, mid_edges])).tolist()
extruded_faces = np_zeros((len(np_edges), 4), dtype=int)
extruded_faces[:, :2] = np_edges
extruded_faces[:, 2] = top_edges[:, 1]
extruded_faces[:, 3] = top_edges[:, 0]
extruded_faces_py = extruded_faces.tolist()
if isinstance(edges, np_ndarray):
new_edges = np_concatenate([edges, top_edges, mid_edges]).tolist()
else:
new_edges = edges + extruded_edges_py
if faces and faces[0]:
if isinstance(faces, np_ndarray):
new_faces = np_concatenate([faces, extruded_faces]).tolist()
else:
new_faces = faces + extruded_faces_py
else:
new_faces = extruded_faces_py
if face_data:
bvh = bvh_tree_from_polygons(vertices,
faces,
all_triangles=False,
epsilon=0.0,
safe_check=True)
mid_points = (np_verts[np_edges[:, 1]] + np_verts[np_edges[:, 0]]) / 2
face_idx = [bvh.find_nearest(P)[2] for P in mid_points.tolist()]
new_face_data = face_data_matched + [
face_data_matched[p] for p in face_idx
]
else:
new_face_data = []
return (new_vertices, new_edges, new_faces, extruded_verts,
extruded_edges_py, extruded_faces_py, new_face_data)
