def process(self):
if self.outputs['Vectors'].is_linked:
vecs_ = self.inputs['Vectors'].sv_get(deepcopy=False)
vecs = Vector_generate(vecs_)
mats_ = self.inputs['Matrixes'].sv_get(deepcopy=False)
mats = Matrix_generate(mats_)
vectors_ = self.vecscorrect(vecs, mats)
vectors = Vector_degenerate(vectors_)
self.outputs['Vectors'].sv_set(vectors)
def process(self):
# inputs
if self.outputs['Vectors'].is_linked:
vecs_ = SvGetSocketAnyType(self, self.inputs['Vectors'])
vecs = Vector_generate(vecs_)
mats_ = SvGetSocketAnyType(self, self.inputs['Matrixes'])
mats = Matrix_generate(mats_)
vectors_ = self.vecscorrect(vecs, mats)
vectors = Vector_degenerate(vectors_)
SvSetSocketAnyType(self, 'Vectors', vectors)
def process(self):
# inputs
if not self.inputs['Matrix'].is_linked:
return
matrices = self.inputs['Matrix'].sv_get()
matrices = Matrix_generate(matrices)
counts = self.inputs['Iterations'].sv_get()[0]
vertices_s = self.inputs['Vertices'].sv_get()
vertices_s = Vector_generate(vertices_s)
edges_s = self.inputs['Edges'].sv_get(default=[[]])
faces_s = self.inputs['Polygons'].sv_get(default=[[]])
if self.outputs['Vertices'].is_linked:
result_vertices = []
result_edges = []
result_faces = []
if edges_s[0]:
if len(edges_s) != len(vertices_s):
raise Exception("Invalid number of edges: {} != {}".format(
len(edges_s), len(vertices_s)))
if faces_s[0]:
if len(faces_s) != len(vertices_s):
raise Exception(
"Invalid number of polygons: {} != {}".format(
len(faces_s), len(vertices_s)))
meshes = match_long_repeat([vertices_s, edges_s, faces_s, counts])
offset = 0
for vertices, edges, faces, count in zip(*meshes):
result_vertices.extend(vertices)
result_edges.extend(shift_edges(edges, offset))
result_faces.extend(shift_faces(faces, offset))
offset += len(vertices)
new_vertices, new_edges, new_faces = iterate_matrices(
matrices, vertices, edges, faces, count, offset)
offset += len(new_vertices)
result_vertices.extend(new_vertices)
result_edges.extend(new_edges)
result_faces.extend(new_faces)
result_vertices = Vector_degenerate([result_vertices])
self.outputs['Vertices'].sv_set(result_vertices)
if self.outputs['Edges'].is_linked:
self.outputs['Edges'].sv_set([result_edges])
if self.outputs['Polygons'].is_linked:
self.outputs['Polygons'].sv_set([result_faces])
def process(self):
if 'vertices' in self.inputs and self.inputs['vertices'].links \
and self.inputs['edg_pol'].links \
and self.inputs['cut_matrix'].links:
verts_ob = Vector_generate(
SvGetSocketAnyType(self, self.inputs['vertices']))
edg_pols_ob = SvGetSocketAnyType(self, self.inputs['edg_pol'])
if self.inputs['matrix'].links:
matrixs = SvGetSocketAnyType(self, self.inputs['matrix'])
else:
matrixs = []
for le in verts_ob:
matrixs.append(Matrix())
cut_mats = SvGetSocketAnyType(self, self.inputs['cut_matrix'])
verts_out = []
edges_out = []
for cut_mat in cut_mats:
cut_mat = Matrix(cut_mat)
pp = Vector((0.0, 0.0, 0.0)) * cut_mat.transposed()
pno = Vector((0.0, 0.0, 1.0)) * cut_mat.to_3x3().transposed()
verts_pre_out = []
edges_pre_out = []
for idx_mob, matrix in enumerate(matrixs):
idx_vob = min(idx_mob, len(verts_ob) - 1)
idx_epob = min(idx_mob, len(edg_pols_ob) - 1)
matrix = Matrix(matrix)
x_me = section(verts_ob[idx_vob], edg_pols_ob[idx_epob],
matrix, pp, pno, self.fill_check, self.tri)
if x_me:
verts_pre_out.append(x_me['Verts'])
edges_pre_out.append(x_me['Edges'])
if verts_pre_out:
verts_out.extend(verts_pre_out)
edges_out.extend(edges_pre_out)
if 'vertices' in self.outputs and self.outputs['vertices'].links:
output = Vector_degenerate(verts_out)
SvSetSocketAnyType(self, 'vertices', output)
if 'edges' in self.outputs and self.outputs['edges'].links:
SvSetSocketAnyType(self, 'edges', edges_out)
else:
pass
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if not self.inputs['Vertices'].is_linked:
return
vertices_s = self.inputs['Vertices'].sv_get()
paths = self.inputs['Path'].sv_get()
paths = ensure_nesting_level(paths, 3)
objects = match_long_repeat([vertices_s, paths])
result_vertices = []
result_spline = []
for vertices, path in zip(*objects):
# Scale orientation coordinate of input vertices to [0, 1] range
# these values are used to calculate points on the spline
t_values = np.array([vertex[self.orient_axis] for vertex in vertices])
m = t_values.min()
M = t_values.max()
object_size = M - m
if object_size > 0.00001:
t_values = (t_values - m) / object_size
else:
raise Exception("Size of provided object along axis {} is too small".format(self.orient_axis_))
if self.flip:
t_values = 1.0 - t_values
spline = self.build_spline(path)
scale = spline.length(t_values) / object_size
# These are points lying on the spline
# (a projection of object to spline)
spline_vertices = [Vector(v) for v in spline.eval(t_values).tolist()]
spline_tangents = [Vector(v) for v in spline.tangent(t_values, h=self.tangent_precision).tolist()]
new_vertices = []
for src_vertex, spline_vertex, spline_tangent in zip(vertices, spline_vertices, spline_tangents):
# Scaling and rotation matrix
matrix = self.get_matrix(spline_tangent, scale)
# Source vertex projected to plane orthogonal to orientation axis
src_vertex_projection = Vector(src_vertex)
src_vertex_projection[self.orient_axis] = 0
# Scale and rotate the projection, then move it towards spline vertex
new_vertex = matrix @ Vector(src_vertex_projection) + spline_vertex
new_vertices.append(new_vertex)
result_vertices.append(new_vertices)
self.outputs['Vertices'].sv_set(Vector_degenerate(result_vertices))
def sv_main(powers=[], pow_str=[], points=[], lent=0.1, subs=30):
in_sockets = [['v', 'powers', powers], ['s', 'pow_str', pow_str],
['v', 'points', points], ['s', 'lent', lent],
['s', 'subs', subs]]
verts_out = []
edges_out = []
def out_sockets():
return [['v', 'verts_out', verts_out], ['s', 'faces_out', edges_out]]
if not all([powers, pow_str, points]):
return in_sockets, out_sockets()
#powers = [np.array(i) for i in powers[0]]
#points = [np.array(i) for i in points[0]]
points = Vector_generate(points)[0]
powers = Vector_generate(powers)[0]
def nextpoint(poi, powers):
verts_ = [poi - pow for pow in powers]
vect = Vector()
for i in verts_:
vect += i * (1 / i.length**2)
vect.normalize()
# additional power:
#cos(x)
#sin
#3*exp(-(x**2+3**2)**2)
vertnext = poi + vect * (1 / lent)
return vertnext
v = []
for poi in points:
vers = []
edgs = []
for k in range(subs):
vertnext = nextpoint(poi, powers)
vers.append(poi)
poi = vertnext
if k > 0:
edgs.append([k - 1, k])
edges_out.append(edgs)
verts_out.append(vers)
verts_out = Vector_degenerate(verts_out)
return in_sockets, out_sockets()
def sv_main(verts=[], polygons=[], matrix=[], ver=3, hor=3):
in_sockets = [['v', 'verts', verts], ['s', 'polygons', polygons],
['m', 'matrix', matrix], ['s', 'vertical', ver],
['s', 'horisontal', hor]]
verts_out = []
matrixes = []
ver = max(3, ver)
hor = max(3, hor)
def out_sockets():
return [['v', 'verts_out', verts_out], ['m', 'matrixes', matrixes]]
if not all([verts, polygons]):
return in_sockets, out_sockets()
def make_centers(v, p, m):
out = []
matrixes = []
vlh = v[pol[1]] - v[pol[0]]
vlv = v[pol[3]] - v[pol[0]]
for i in range(hor - 1):
per_h = (1 / hor) * (i + 1)
for k in range(ver - 1):
per_v = (1 / ver) * (k + 1)
v_loc = v[pol[0]] + vlh * per_h + vlv * per_v
m.translation = v_loc
matrixes.append(m.copy())
out.append(v_loc)
return out, matrixes
# paradigm change
verts = Vector_generate(verts)
matrix = Matrix_generate(matrix)
centers = []
for p, v in zip(polygons, verts):
centers_ = []
for pol, m in zip(p, matrix):
cout, mout = make_centers(v, pol, m)
centers_.extend(cout)
matrixes.extend(mout)
centers.append(centers_)
#print(centers,matrixes)
#bpy.data.shape_keys['Key'].key_blocks['Key 1'].value
verts_out = Vector_degenerate(centers)
matrixes = Matrix_listing(matrixes)
return in_sockets, out_sockets()
def process(self):
mandatory_sockets = [
self.inputs['vertices'], self.inputs['edg_pol'],
self.inputs['cut_matrix']
]
if not all([s.is_linked for s in mandatory_sockets]):
return
verts_ob = Vector_generate(self.inputs['vertices'].sv_get())
edg_pols_ob = self.inputs['edg_pol'].sv_get()
if self.inputs['matrix'].is_linked:
matrixs = self.inputs['matrix'].sv_get()
else:
matrixs = []
for le in verts_ob:
matrixs.append(Matrix())
cut_mats = self.inputs['cut_matrix'].sv_get()
verts_out = []
edges_out = []
for cut_mat in cut_mats:
cut_mat = Matrix(cut_mat)
pp = Vector((0.0, 0.0, 0.0)) * cut_mat.transposed()
pno = Vector((0.0, 0.0, 1.0)) * cut_mat.to_3x3().transposed()
verts_pre_out = []
edges_pre_out = []
for idx_mob, matrix in enumerate(matrixs):
idx_vob = min(idx_mob, len(verts_ob) - 1)
idx_epob = min(idx_mob, len(edg_pols_ob) - 1)
matrix = Matrix(matrix)
x_me = section(verts_ob[idx_vob], edg_pols_ob[idx_epob],
matrix, pp, pno, self.fill_check, self.tri)
if x_me:
verts_pre_out.append(x_me['Verts'])
edges_pre_out.append(x_me['Edges'])
if verts_pre_out:
verts_out.extend(verts_pre_out)
edges_out.extend(edges_pre_out)
self.outputs['vertices'].sv_set(Vector_degenerate(verts_out))
self.outputs['edges'].sv_set(edges_out)
def noise_displace(params, constant, matching_f):
result = []
noise_function, noise_type, match_mode = constant
params = matching_f(params)
local_match = iter_list_match_func[match_mode]
for props in zip(*params):
verts, pols, seed_val, scale_out, matrix = props
if type(matrix) == list:
matrix = [m.inverted() for m in matrix]
else:
matrix = [matrix.inverted()]
if len(seed_val) > 1:
m_prop = local_match([seed_val, scale_out, matrix])
else:
m_prop = local_match([scale_out, matrix])
seed_val = seed_val[0]
noise.seed_set(int(seed_val) if seed_val else 1385)
noise_function(verts, pols, m_prop, noise_type, result)
return Vector_degenerate(result)
def sv_main(verts=[], polygons=[], ver=3, hor=3):
in_sockets = [['v', 'verts', verts], ['s', 'polygons', polygons],
['s', 'vertical', ver], ['s', 'horisontal', hor]]
verts_out = []
ver = max(3, ver)
hor = max(3, hor)
def out_sockets():
return [['v', 'verts_out', verts_out]]
if not all([verts, polygons]):
return in_sockets, out_sockets()
def make_centers(v, p):
#gn = G.normal([v[i] for i in p])
out = []
vlh = v[pol[1]] - v[pol[0]]
vlv = v[pol[3]] - v[pol[0]]
for i in range(hor - 1):
per_h = (1 / hor) * (i + 1)
for k in range(ver - 1):
per_v = (1 / ver) * (k + 1)
out.append(v[pol[0]] + vlh * per_h + vlv * per_v)
return out
# paradigm change
verts = Vector_generate(verts)
centers = []
for p, v in zip(polygons, verts):
centers_ = []
for pol in p:
centers_.extend(make_centers(v, pol))
centers.append(centers_)
#bpy.data.shape_keys['Key'].key_blocks['Key 1'].value
verts_out = Vector_degenerate(centers)
return in_sockets, out_sockets()
def process(self):
if not self.noise_dict:
self.noise_dict = {
t[0]: t[1]
for t in inspect.getmembers(noise.types)
if isinstance(t[1], int)
}
if not self.outputs[0].is_linked:
return
verts = Vector_generate(self.inputs['Vertices'].sv_get())
out = []
n_t = self.noise_dict[self.noise_type]
n_f = self.noise_f[self.out_mode]
for obj in verts:
out.append([n_f(v, n_t) for v in obj])
if 'Noise V' in self.outputs:
self.outputs['Noise V'].sv_set(Vector_degenerate(out))
else:
self.outputs['Noise S'].sv_set(out)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
tfunc = turbulence_f[self.out_mode]
verts = inputs['Vertices'].sv_get(deepcopy=False)
maxlen = len(verts)
arguments = [verts]
# gather socket data into arguments
for socket in inputs[1:]:
data = socket.sv_get()[0]
fullList(data, maxlen)
arguments.append(data)
# iterate over vert lists and pass arguments to the turbulence function
out = []
for idx, (vert_list, octaves, hard, amp, freq,
seed) in enumerate(zip(*arguments)):
final_vert_list = seed_adjusted(vert_list, seed)
out.append([
tfunc(v,
octaves,
hard,
noise_basis=self.noise_type,
amplitude_scale=amp,
frequency_scale=freq) for v in final_vert_list
])
if 'Noise V' in outputs:
out = Vector_degenerate(out)
outputs[0].sv_set(out)
def process(self):
# VerticesR & EdgesR or Vertex1 & Vertex2 are necessary anyway
# to define recipient edge
if self.input_mode == "edge":
if not (self.inputs['VerticesR'].is_linked
and self.inputs['EdgesR'].is_linked):
return
elif self.input_mode == "fixed":
if not (self.inputs['Vertex1'].is_linked
and self.inputs['Vertex2'].is_linked):
return
# Input vertices are used now to define count of objects.
# Theoretically it is possible to not use them in "Count" mode.
if not self.inputs['Vertices'].is_linked:
return
vertices_s = self.inputs['Vertices'].sv_get(default=[[]])
vertices_s = Vector_generate(vertices_s)
edges_s = self.inputs['Edges'].sv_get(default=[[]])
faces_s = self.inputs['Polygons'].sv_get(default=[[]])
inp_vertices1_s = self.inputs['Vertex1'].sv_get(default=[[]])
inp_vertices1_s = Vector_generate(inp_vertices1_s)[0]
inp_vertices2_s = self.inputs['Vertex2'].sv_get(default=[[]])
inp_vertices2_s = Vector_generate(inp_vertices2_s)[0]
vertices_r = self.inputs['VerticesR'].sv_get(default=[[]])
vertices_r = Vector_generate(vertices_r)[0]
edges_r = self.inputs['EdgesR'].sv_get(default=[[]])[0]
counts = self.inputs['Count'].sv_get()[0]
paddings = self.inputs['Padding'].sv_get()[0]
vertices1_s, vertices2_s = self.get_recipient_vertices(
inp_vertices1_s, inp_vertices2_s, vertices_r, edges_r)
# It may be also useful to output just matrices, without vertices or edges/faces
if self.outputs['Vertices'].is_linked or self.outputs[
'Matrices'].is_linked:
result_matrices = []
result_vertices = []
result_edges = []
result_faces = []
meshes = match_long_repeat([
vertices_s, edges_s, faces_s, vertices1_s, vertices2_s, counts,
paddings
])
for vertices, edges, faces, vertex1, vertex2, inp_count, padding in zip(
*meshes):
count = self.get_count(vertex1, vertex2, vertices, inp_count,
padding)
count = max(count, 1)
new_matrices, new_vertices = self.duplicate_vertices(
vertex1, vertex2, vertices, edges, faces, count, padding)
result_edges.extend([edges] * count)
result_faces.extend([faces] * count)
result_vertices.extend(new_vertices)
result_matrices.extend(new_matrices)
result_vertices = Vector_degenerate(result_vertices)
result_matrices = Matrix_degenerate(result_matrices)
self.outputs['Vertices'].sv_set(result_vertices)
if self.outputs['Edges'].is_linked:
self.outputs['Edges'].sv_set(result_edges)
if self.outputs['Polygons'].is_linked:
self.outputs['Polygons'].sv_set(result_faces)
if self.outputs['Matrices'].is_linked:
self.outputs['Matrices'].sv_set(result_matrices)
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 all(s.is_linked for s in self.inputs[:-1]):
if self.inputs['Z_Coef'].is_linked:
z_coef = self.inputs['Z_Coef'].sv_get()[0]
else:
z_coef = []
polsR = self.inputs['PolsR'].sv_get()[0] # recipient one object [0]
versR = self.inputs['VersR'].sv_get()[0] # recipient
polsD = self.inputs['PolsD'].sv_get() # donor many objects [:]
versD_ = self.inputs['VersD'].sv_get() # donor
versD = Vector_generate(versD_)
polsR, polsD, versD = match_long_repeat([polsR, polsD, versD])
bm = bmesh_from_pydata(versR, [], polsR, normal_update=True)
bm.verts.ensure_lookup_table()
new_ve = bm.verts
vers_out = []
pols_out = []
i = 0
for vD, pR in zip(versD, polsR):
# part of donor to make limits
j = i
pD = polsD[i]
xx = [x[0] for x in vD]
x0 = (self.width_coef) / (max(xx)-min(xx))
yy = [y[1] for y in vD]
y0 = (self.width_coef) / (max(yy)-min(yy))
zz = [z[2] for z in vD]
zzz = (max(zz)-min(zz))
if zzz:
z0 = 1 / zzz
else:
z0 = 0
# part of recipient polygons to reciev donor
last = len(pR)-1
vs = [new_ve[v] for v in pR] # new_ve - temporery data
if z_coef:
if j < len(z_coef):
z1 = z0 * z_coef[j]
else:
z1 = z0
new_vers = []
new_pols = []
for v in vD:
new_vers.append(self.lerp3(vs[0], vs[1], vs[2], vs[last], v, x0, y0, z1))
for p in pD:
new_pols.append([id for id in p])
pols_out.append(new_pols)
vers_out.append(new_vers)
i += 1
bm.free()
output = Vector_degenerate(vers_out)
self.outputs['Vertices'].sv_set(output)
self.outputs['Poligons'].sv_set(pols_out)
def process(self):
if 'vecLine' in self.inputs and \
'vecPlane' in self.inputs and \
'edgPlane' in self.inputs:
print(self.name, 'is starting')
if self.inputs['vecLine'].links and \
self.inputs['vecPlane'].links and \
self.inputs['edgPlane'].links:
if self.bindCircle:
circle = [ (Vector((sin(radians(i)),cos(radians(i)),0))*self.circle_rad)/4 \
for i in range(0,360,30) ]
vec = self.inputs['vecLine'].sv_get()
vecplan = self.inputs['vecPlane'].sv_get()
edgplan = self.inputs['edgPlane'].sv_get()
if len(edgplan[0][0]) > 2:
edgplan = pols_edges(edgplan)
thick = self.inputs['thick'].sv_get()[0][0]
threshold_coplanar = 0.005
sinuso60 = 0.8660254037844386
sinuso60_minus = 0.133974596
sinuso30 = 0.5
sinuso45 = 0.7071067811865475
thick_2 = thick / 2
thick_3 = thick / 3
thick_6 = thick / 6
threshold = self.threshold
if 'vecContr' in self.inputs and self.inputs['vecContr'].links:
vecont = self.inputs['vecContr'].sv_get()
#edgcont = self.inputs['edgContr'].sv_get()
vec_cont = Vector_generate(vecont)
loc_cont = [[i[0]] for i in vec_cont]
norm_cont = [[NM(i[0], i[len(i) // 2], i[-1])]
for i in vec_cont] # довести до ума
else:
vec_cont = []
if 'vecTube' in self.inputs and self.inputs['vecTube'].links:
vectube = self.inputs['vecTube'].sv_get()
vec_tube = Vector_generate(vectube)
tube_radius = self.inputs['radTube'].sv_get()[0][0]
circle_tube = [ (Vector((sin(radians(i)),cos(radians(i)),0))*tube_radius) \
for i in range(0,360,15) ]
else:
vec_tube = []
outeup = []
outelo = []
vupper = []
vlower = []
centers = []
vec_ = Vector_generate(vec)
vecplan_ = Vector_generate(vecplan)
for centersver, vecp, edgp in zip(vecplan, vecplan_, edgplan):
tubes_flag_bed_solution_i_know = False
newinds1 = [list(e) for e in edgp]
newinds2 = newinds1.copy()
vupperob = vecp.copy()
vlowerob = vecp.copy()
deledges1 = []
deledges2 = []
# to define bounds
x = [i[0] for i in vecp]
y = [i[1] for i in vecp]
z = [i[2] for i in vecp]
m1x, m2x, m1y, m2y, m1z, m2z = max(x), min(x), max(y), min(
y), max(z), min(z)
l = Vector(
(sum(x) / len(x), sum(y) / len(y), sum(z) / len(z)))
n_select = [vecp[0], vecp[len(vecp) // 2],
vecp[-1]] # довести до ума
n_select.sort(key=lambda x: sum(x[:]), reverse=False)
n_ = NM(n_select[0], n_select[1], n_select[2])
n_.normalize()
# а виновта ли нормаль?
if n_[0] < 0:
n = n_ * -1
else:
n = n_
cen = [sum(i) for i in zip(*centersver)]
centers.append(Vector(cen) / len(centersver))
k = 0
lenvep = len(vecp)
# KDtree collections closest to join edges to sockets
tree = KDT.KDTree(lenvep)
for i, v in enumerate(vecp):
tree.insert(v, i)
tree.balance()
# vertical edges iterations
# every edge is object - two points, one edge
for v in vec_:
if not v: continue
# sort vertices by Z value
# find two vertices - one lower, two upper
vlist = [v[0], v[1]]
vlist.sort(key=lambda x: x[2], reverse=False)
# flip if coplanar to enemy plane
# flip plane coplanar
if vec_cont:
fliped = self.get_coplanar(v[0], loc_cont,
norm_cont, vec_cont)
else:
fliped = False
shortedge = (vlist[1] - vlist[0]).length
if fliped:
two, one = vlist
else:
one, two = vlist
# coplanar to owner
cop = abs(D2P(one, l, n))
# defining bounds
inside = one[0]<m1x and one[0]>m2x and one[1]<m1y and one[1]>m2y \
and one[2]<=m1z and one[2]>=m2z
# if in bounds and coplanar do:
#print(self.name,l, cop, inside)
if cop < threshold_coplanar and inside and shortedge > thick * threshold:
'''
huge calculations. if we can reduce...
'''
# find shift for thickness in sockets
diry = two - one
diry.normalize()
# solution for vertical wafel - cool but not in diagonal case
# angle = radians(degrees(atan(n.y/n.x))+90)
dirx_ = self.rotation_on_axis(diry, n, radians(90))
dirx = dirx_ * thick_2
# вектор, индекс, расстояние
# запоминаем порядок находим какие удалить рёбра
# делаем выборку левая-правая точка
nearv_1, near_1 = tree.find(one)[:2]
nearv_2, near_2 = tree.find(two)[:2]
# indexes of two nearest points
# удалить рёбра что мешают спать заодно
en_0, en_1, de1 = self.calc_indexes(edgp, near_1)
deledges1.extend(de1)
en_2, en_3, de2 = self.calc_indexes(edgp, near_2)
deledges2.extend(de2)
# print(vecp, one, dirx, en_0, en_1)
# left-right indexes and vectors
# с учётом интерполяций по высоте
l1, r1, lz1, rz1 = \
self.calc_leftright(vecp, one, dirx, en_0, en_1, thick_2, diry)
l2, r2, lz2, rz2 = \
self.calc_leftright(vecp, two, dirx, en_2, en_3, thick_2, diry)
# print(left2, right2, l2, r2, lz2, rz2)
# средняя точка и её смещение по толщине материала
three = (one - two) / 2 + two
# rounded section
if self.rounded:
'''рёбра'''
# пазы формируем независимо от верх низ
outeob1 = [[lenvep + k + 8, lenvep + k],
[lenvep + k + 1, lenvep + k + 2],
[lenvep + k + 2, lenvep + k + 3],
[lenvep + k + 3, lenvep + k + 4],
[lenvep + k + 4, lenvep + k + 5],
[lenvep + k + 5, lenvep + k + 6],
[lenvep + k + 6, lenvep + k + 7],
[lenvep + k + 7, lenvep + k + 8],
[lenvep + k + 9, lenvep + k + 1]]
outeob2 = [[lenvep + k, lenvep + k + 1],
[lenvep + k + 1, lenvep + k + 2],
[lenvep + k + 2, lenvep + k + 3],
[lenvep + k + 3, lenvep + k + 4],
[lenvep + k + 4, lenvep + k + 5],
[lenvep + k + 5, lenvep + k + 6],
[lenvep + k + 6, lenvep + k + 7],
[lenvep + k + 7, lenvep + k + 8],
[lenvep + k + 8, lenvep + k + 9]]
# наполнение списков lenvep = length(vecp)
newinds1.extend([[l1, lenvep + k],
[lenvep + k + 9, r1]])
newinds2.extend([[l2, lenvep + k + 9],
[lenvep + k, r2]])
'''Вектора'''
round1 = diry * thick_3
round2 = diry * thick_3 * sinuso30
round2_ = dirx / 3 + dirx * (2 * sinuso60 / 3)
round3 = diry * thick_3 * sinuso60_minus
round3_ = dirx / 3 + dirx * (2 * sinuso30 / 3)
round4 = dirx / 3
vupperob.extend([
lz2, three + round1 - dirx,
three + round2 - round2_,
three + round3 - round3_, three - round4,
three + round4, three + round3 + round3_,
three + round2 + round2_,
three + round1 + dirx, rz2
])
vlowerob.extend([
rz1, three - round1 - dirx,
three - round2 - round2_,
three - round3 - round3_, three - round4,
three + round4, three - round3 + round3_,
three - round2 + round2_,
three - round1 + dirx, lz1
])
k += 10
# streight section
else:
'''рёбра'''
# пазы формируем независимо от верх низ
outeob1 = [[lenvep + k, lenvep + k + 1],
[lenvep + k + 1, lenvep + k + 2],
[lenvep + k + 2, lenvep + k + 3]]
outeob2 = [[lenvep + k, lenvep + k + 1],
[lenvep + k + 1, lenvep + k + 2],
[lenvep + k + 2, lenvep + k + 3]]
# наполнение списков lenvep = length(vecp)
newinds1.extend([[l1, lenvep + k],
[lenvep + k + 3, r1]])
newinds2.extend([[l2, lenvep + k + 3],
[lenvep + k, r2]])
'''Вектора'''
vupperob.extend(
[lz2, three - dirx, three + dirx, rz2])
vlowerob.extend(
[rz1, three + dirx, three - dirx, lz1])
k += 4
newinds1.extend(outeob1)
newinds2.extend(outeob2)
# circles to bing panels section
if self.bindCircle:
CP = self.circl_place
if CP == 'Midl':
crcl_cntr = IL2P(one, two, Vector(
(0, 0, 0)), Vector((0, 0, -1)))
elif CP == 'Up' and not fliped:
crcl_cntr = two - diry * self.circle_rad * 2
elif CP == 'Down' and not fliped:
crcl_cntr = one + diry * self.circle_rad * 2
elif CP == 'Up' and fliped:
crcl_cntr = one + diry * self.circle_rad * 2
elif CP == 'Down' and fliped:
crcl_cntr = two - diry * self.circle_rad * 2
# forgot howto 'else' in line iteration?
outeob1 = [[
lenvep + k + i, lenvep + k + i + 1
] for i in range(0, 11)]
outeob1.append([lenvep + k, lenvep + k + 11])
outeob2 = [[
lenvep + k + i, lenvep + k + i + 1
] for i in range(12, 23)]
outeob2.append(
[lenvep + k + 12, lenvep + k + 23])
newinds1.extend(outeob1 + outeob2)
newinds2.extend(outeob1 + outeob2)
mat_rot_cir = n.rotation_difference(
Vector((0, 0, 1))).to_matrix().to_4x4()
circle_to_add_1 = [vecir*mat_rot_cir+crcl_cntr+ \
dirx_*self.circle_rad for vecir in circle ]
circle_to_add_2 = [vecir*mat_rot_cir+crcl_cntr- \
dirx_*self.circle_rad for vecir in circle ]
vupperob.extend(circle_to_add_1 +
circle_to_add_2)
vlowerob.extend(circle_to_add_1 +
circle_to_add_2)
k += 24
# TUBE section
if vec_tube and not tubes_flag_bed_solution_i_know:
for v in vec_tube:
tubeverlength = len(v)
if tubeverlength == 2:
crcl_cntr = IL2P(v[0], v[1], l, n)
if crcl_cntr:
inside = crcl_cntr[0]<m1x and crcl_cntr[0]>m2x and crcl_cntr[1]<m1y \
and crcl_cntr[1]>m2y and crcl_cntr[2]<=m1z and crcl_cntr[2]>=m2z
if inside:
outeob = [[
lenvep + k + i,
lenvep + k + i + 1
] for i in range(0, 23)]
outeob.append([
lenvep + k, lenvep + k + 23
])
newinds1.extend(outeob)
newinds2.extend(outeob)
mat_rot_cir = n.rotation_difference(
Vector(
(0, 0, 1))).to_matrix(
).to_4x4()
circle_to_add = [
vecir * mat_rot_cir +
crcl_cntr
for vecir in circle_tube
]
vupperob.extend(circle_to_add)
vlowerob.extend(circle_to_add)
k += 24
else:
tubeshift = tubeverlength // 2
crcl_cntr = IL2P(
v[0], v[tubeshift], l, n)
if crcl_cntr:
inside = crcl_cntr[0]<m1x and crcl_cntr[0]>m2x and crcl_cntr[1]<m1y \
and crcl_cntr[1]>m2y and crcl_cntr[2]<=m1z and crcl_cntr[2]>=m2z
if inside:
outeob = [[
lenvep + k + i,
lenvep + k + i + 1
] for i in range(tubeshift - 1)
]
outeob.append([
lenvep + k,
lenvep + k + tubeshift - 1
])
newinds1.extend(outeob)
newinds2.extend(outeob)
for tubevert in range(
tubeshift):
tubevert_out = IL2P(
v[tubevert],
v[tubevert +
tubeshift], l, n)
vupperob.append(
tubevert_out)
vlowerob.append(
tubevert_out)
k += tubeshift
tubes_flag_bed_solution_i_know = True
elif cop < threshold_coplanar and inside and shortedge <= thick * threshold:
vupperob.extend([one, two])
vlowerob.extend([one, two])
newinds1.append([lenvep + k, lenvep + k + 1])
newinds2.append([lenvep + k, lenvep + k + 1])
k += 2
del tree
for e in deledges1:
if e in newinds1:
newinds1.remove(e)
for e in deledges2:
if e in newinds2:
newinds2.remove(e)
if vupperob or vlowerob:
outeup.append(newinds2)
outelo.append(newinds1)
vupper.append(vupperob)
vlower.append(vlowerob)
vupper = Vector_degenerate(vupper)
vlower = Vector_degenerate(vlower)
centers = Vector_degenerate([centers])
if 'vert' in self.outputs:
if self.out_up_down == 'Up':
out = dataCorrect(vupper)
else:
out = dataCorrect(vlower)
self.outputs['vert'].sv_set(out)
if 'edge' in self.outputs and self.outputs['edge'].links:
if self.out_up_down == 'Up':
self.outputs['edge'].sv_set(outeup)
else:
self.outputs['edge'].sv_set(outelo)
if 'centers' in self.outputs and self.outputs['centers'].links:
self.outputs['centers'].sv_set(centers)
print(self.name, 'is finishing')
def process(self):
verts_socket, poly_socket = self.inputs
norm_socket, norm_abs_socket, origins_socket, centers_socket = self.outputs
if not any([s.is_linked for s in self.outputs]):
return
if not (verts_socket.is_linked and poly_socket.is_linked):
return
pols_ = poly_socket.sv_get()
vers_tupls = verts_socket.sv_get()
vers_vects = Vector_generate(vers_tupls)
# make mesh temp утилитарно - удалить в конце
mat_collect = []
normals_out = []
origins = []
norm_abs_out = []
for verst, versv, pols in zip(vers_tupls, vers_vects, pols_):
# medians в векторах
medians = []
normals = []
centrs = []
norm_abs = []
for p in pols:
# medians
# it calcs middle point of opposite edges,
# than finds length vector between this two points
v0 = versv[p[0]]
v1 = versv[p[1]]
v2 = versv[p[2]]
lp = len(p)
if lp >= 4:
l = ((lp - 2) // 2) + 2
v3 = versv[p[l]]
poi_2 = (v2 + v3) / 2
# normals
norm = geometry.normal(v0, v1, v2, v3)
normals.append(norm)
else:
poi_2 = v2
# normals
norm = geometry.normal(v0, v1, v2)
normals.append(norm)
poi_1 = (v0 + v1) / 2
vm = poi_2 - poi_1
medians.append(vm)
# centrs
x, y, z = zip(*[verst[poi] for poi in p])
x, y, z = sum(x) / len(x), sum(y) / len(y), sum(z) / len(z)
current_center = Vector((x, y, z))
centrs.append(current_center)
# normal absolute !!!
# это совершенно нормально!!! ;-)
norm_abs.append(current_center + norm)
if self.Separate:
norm_abs_out.append(norm_abs)
origins.append(centrs)
normals_out.append(normals)
else:
norm_abs_out.extend(norm_abs)
origins.extend(centrs)
normals_out.extend(normals)
mat_collect_ = []
for cen, med, nor in zip(centrs, medians, normals):
loc = Matrix.Translation(cen)
# need better solution for Z,Y vectors + may be X vector correction
vecz = Vector((0, 1e-6, 1))
q_rot0 = vecz.rotation_difference(nor).to_matrix().to_4x4()
q_rot2 = nor.rotation_difference(vecz).to_matrix().to_4x4()
if med[1] > med[0]:
vecy = Vector((1e-6, 1, 0)) * q_rot2
else:
vecy = Vector((1, 1e-6, 0)) * q_rot2
q_rot1 = vecy.rotation_difference(med).to_matrix().to_4x4()
# loc is matrix * rot vector * rot vector
M = loc * q_rot1 * q_rot0
lM = [j[:] for j in M]
mat_collect_.append(lM)
mat_collect.extend(mat_collect_)
if not self.Separate:
norm_abs_out = [norm_abs_out]
origins = [origins]
normals_out = [normals_out]
centers_socket.sv_set(mat_collect)
norm_abs_socket.sv_set(Vector_degenerate(norm_abs_out))
origins_socket.sv_set(Vector_degenerate(origins))
norm_socket.sv_set(Vector_degenerate(normals_out))
def process(self):
if self.outputs['Centers'].is_linked or self.outputs['Normals'].is_linked or \
self.outputs['Origins'].is_linked or self.outputs['Norm_abs'].is_linked:
if 'Polygons' in self.inputs and 'Vertices' in self.inputs \
and self.inputs['Polygons'].is_linked and self.inputs['Vertices'].is_linked:
pols_ = SvGetSocketAnyType(self, self.inputs['Polygons'])
vers_tupls = SvGetSocketAnyType(self, self.inputs['Vertices'])
vers_vects = Vector_generate(vers_tupls)
# make mesh temp утилитарно - удалить в конце
mat_collect = []
normals_out = []
origins = []
norm_abs_out = []
for verst, versv, pols in zip(vers_tupls, vers_vects, pols_):
# medians в векторах
medians = []
normals = []
centrs = []
norm_abs = []
for p in pols:
# medians
# it calcs middle point of opposite edges,
# than finds length vector between this two points
v0 = versv[p[0]]
v1 = versv[p[1]]
v2 = versv[p[2]]
lp=len(p)
if lp >= 4:
l = ((lp-2)//2) + 2
v3 = versv[p[l]]
poi_2 = (v2+v3)/2
# normals
norm = geometry.normal(v0, v1, v2, v3)
normals.append(norm)
else:
poi_2 = v2
# normals
norm = geometry.normal(v0, v1, v2)
normals.append(norm)
poi_1 = (v0+v1)/2
vm = poi_2 - poi_1
medians.append(vm)
# centrs
x,y,z = zip(*[verst[poi] for poi in p])
x,y,z = sum(x)/len(x), sum(y)/len(y), sum(z)/len(z)
current_center = Vector((x,y,z))
centrs.append(current_center)
# normal absolute !!!
# это совершенно нормально!!! ;-)
norm_abs.append(current_center+norm)
norm_abs_out.append(norm_abs)
origins.append(centrs)
normals_out.extend(normals)
mat_collect_ = []
for cen, med, nor in zip(centrs, medians, normals):
loc = Matrix.Translation(cen)
# need better solution for Z,Y vectors + may be X vector correction
vecz = Vector((0, 1e-6, 1))
q_rot0 = vecz.rotation_difference(nor).to_matrix().to_4x4()
q_rot2 = nor.rotation_difference(vecz).to_matrix().to_4x4()
vecy = Vector((1e-6, 1, 0)) * q_rot2
q_rot1 = vecy.rotation_difference(med).to_matrix().to_4x4()
# loc is matrix * rot vector * rot vector
M = loc*q_rot1*q_rot0
lM = [ j[:] for j in M ]
mat_collect_.append(lM)
mat_collect.extend(mat_collect_)
SvSetSocketAnyType(self, 'Centers', mat_collect)
SvSetSocketAnyType(self, 'Norm_abs', Vector_degenerate(norm_abs_out))
SvSetSocketAnyType(self, 'Origins', Vector_degenerate(origins))
SvSetSocketAnyType(self, 'Normals', Vector_degenerate([normals_out]))
def process(self):
verts_socket, poly_socket = self.inputs
norm_socket, norm_abs_socket, origins_socket, centers_socket = self.outputs
if not any([s.is_linked for s in self.outputs]):
return
if not (verts_socket.is_linked and poly_socket.is_linked):
return
pols_ = poly_socket.sv_get()
vers_tupls = verts_socket.sv_get()
vers_vects = Vector_generate(vers_tupls)
# make mesh temp утилитарно - удалить в конце
mat_collect = []
normals_out = []
origins = []
norm_abs_out = []
for verst, versv, pols in zip(vers_tupls, vers_vects, pols_):
normals = []
centrs = []
norm_abs = []
p0_xdirs = []
for p in pols:
v0 = versv[p[0]]
v1 = versv[p[1]]
v2 = versv[p[2]]
# save direction of 1st point in polygon
p0_xdirs.append(v0)
# normals
norm = geometry.normal(v0, v1, v2)
normals.append(norm)
# centrs
x, y, z = zip(*[verst[poi] for poi in p])
x, y, z = sum(x) / len(x), sum(y) / len(y), sum(z) / len(z)
current_center = Vector((x, y, z))
centrs.append(current_center)
# normal absolute !!!
# это совершенно нормально!!! ;-)
norm_abs.append(current_center + norm)
if self.Separate:
norm_abs_out.append(norm_abs)
origins.append(centrs)
normals_out.append(normals)
else:
norm_abs_out.extend(norm_abs)
origins.extend(centrs)
normals_out.extend(normals)
mat_collect_ = []
for cen, nor, p0 in zip(centrs, normals, p0_xdirs):
zdir = nor
xdir = (Vector(p0) - cen).normalized()
ydir = zdir.cross(xdir)
lM = [(xdir[0], ydir[0], zdir[0], cen[0]),
(xdir[1], ydir[1], zdir[1], cen[1]),
(xdir[2], ydir[2], zdir[2], cen[2]),
(0.0, 0.0, 0.0, 1.0)]
mat_collect_.append(Matrix(lM))
mat_collect.extend(mat_collect_)
if not self.Separate:
norm_abs_out = [norm_abs_out]
origins = [origins]
normals_out = [normals_out]
centers_socket.sv_set(mat_collect)
norm_abs_socket.sv_set(Vector_degenerate(norm_abs_out))
origins_socket.sv_set(Vector_degenerate(origins))
norm_socket.sv_set(Vector_degenerate(normals_out))
def process(self):
if self.outputs['Centers'].is_linked or self.outputs['Normals'].is_linked or \
self.outputs['Origins'].is_linked or self.outputs['Norm_abs'].is_linked:
if 'Polygons' in self.inputs and 'Vertices' in self.inputs \
and self.inputs['Polygons'].is_linked and self.inputs['Vertices'].is_linked:
pols_ = SvGetSocketAnyType(self, self.inputs['Polygons'])
vers_tupls = SvGetSocketAnyType(self, self.inputs['Vertices'])
vers_vects = Vector_generate(vers_tupls)
# make mesh temp утилитарно - удалить в конце
mat_collect = []
normals_out = []
origins = []
norm_abs_out = []
for verst, versv, pols in zip(vers_tupls, vers_vects, pols_):
normals = []
centrs = []
norm_abs = []
p0_xdirs = []
for p in pols:
v0 = versv[p[0]]
v1 = versv[p[1]]
v2 = versv[p[2]]
# save direction of 1st point in polygon
p0_xdirs.append(v0)
# normals
norm = geometry.normal(v0, v1, v2)
normals.append(norm)
# centrs
x, y, z = zip(*[verst[poi] for poi in p])
x, y, z = sum(x) / len(x), sum(y) / len(y), sum(
z) / len(z)
current_center = Vector((x, y, z))
centrs.append(current_center)
# normal absolute !!!
# это совершенно нормально!!! ;-)
norm_abs.append(current_center + norm)
if self.Separate:
norm_abs_out.append(norm_abs)
origins.append(centrs)
normals_out.append(normals)
else:
norm_abs_out.extend(norm_abs)
origins.extend(centrs)
normals_out.extend(normals)
mat_collect_ = []
for cen, nor, p0 in zip(centrs, normals, p0_xdirs):
zdir = nor
xdir = (Vector(p0) - cen).normalized()
ydir = zdir.cross(xdir)
lM = [(xdir[0], ydir[0], zdir[0], cen[0]),
(xdir[1], ydir[1], zdir[1], cen[1]),
(xdir[2], ydir[2], zdir[2], cen[2]),
(0.0, 0.0, 0.0, 1.0)]
mat_collect_.append(lM)
mat_collect.extend(mat_collect_)
if not self.Separate:
SvSetSocketAnyType(self, 'Centers', mat_collect)
SvSetSocketAnyType(self, 'Norm_abs',
Vector_degenerate([norm_abs_out]))
SvSetSocketAnyType(self, 'Origins',
Vector_degenerate([origins]))
SvSetSocketAnyType(self, 'Normals',
Vector_degenerate([normals_out]))
else:
SvSetSocketAnyType(self, 'Centers', mat_collect)
SvSetSocketAnyType(self, 'Norm_abs',
Vector_degenerate(norm_abs_out))
SvSetSocketAnyType(self, 'Origins',
Vector_degenerate(origins))
SvSetSocketAnyType(self, 'Normals',
Vector_degenerate(normals_out))
def process(self):
# достаём два слота - вершины и полики
if 'Vertices' in self.outputs and self.outputs['Vertices'].links:
if (self.inputs['PolsR'].links and self.inputs['VersR'].links
and self.inputs['VersD'].links
and self.inputs['PolsD'].links):
if self.inputs['Z_Coef'].links:
z_coef = SvGetSocketAnyType(self, self.inputs['Z_Coef'])[0]
else:
z_coef = []
polsR = SvGetSocketAnyType(
self, self.inputs['PolsR'])[0] # recipient one object [0]
versR = SvGetSocketAnyType(
self, self.inputs['VersR'])[0] # recipient
polsD = SvGetSocketAnyType(
self, self.inputs['PolsD']) # donor many objects [:]
versD_ = SvGetSocketAnyType(self,
self.inputs['VersD']) # donor
versD = Vector_generate(versD_)
##### it is needed for normals of vertices
bm = bmesh_from_pydata(versR, [], polsR)
bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
bm.verts.ensure_lookup_table()
new_ve = bm.verts
#new_me = bpy.data.meshes.new('recepient')
#new_me.from_pydata(versR, [], polsR)
#new_me.update(calc_edges=True)
#new_ve = new_me.vertices
#print (new_ve[0].normal, 'normal')
for i, vD in enumerate(versD):
pD = polsD[i]
n_verts = len(vD)
n_faces = len(pD)
xx = [x[0] for x in vD]
x0 = (self.width_coef) / (max(xx) - min(xx))
yy = [y[1] for y in vD]
y0 = (self.width_coef) / (max(yy) - min(yy))
zz = [z[2] for z in vD]
zzz = (max(zz) - min(zz))
if zzz:
z0 = 1 / zzz
else:
z0 = 0
#print (x0, y0, z0)
vers_out = []
pols_out = []
for j, pR in enumerate(polsR):
last = len(pR) - 1
vs = [new_ve[v]
for v in pR] # new_ve - temporery data
if z_coef:
if j < len(z_coef):
z1 = z0 * z_coef[j]
else:
z1 = z0
new_vers = []
new_pols = []
for v in vD:
new_vers.append(
self.lerp3(vs[0], vs[1], vs[2], vs[last], v,
x0, y0, z1))
for p in pD:
new_pols.append([id for id in p])
pols_out.append(new_pols)
vers_out.append(new_vers)
#bpy.data.meshes.remove(new_me) # cleaning and washing
bm.free()
#print (Vector_degenerate(vers_out))
output = Vector_degenerate(vers_out)
#print (output)
if 'Vertices' in self.outputs and self.outputs[
'Vertices'].links:
SvSetSocketAnyType(self, 'Vertices', output)
if 'Poligons' in self.outputs and self.outputs[
'Poligons'].links:
SvSetSocketAnyType(self, 'Poligons', pols_out)