def update(self):
multi_socket(self, min=2)
if 'x0' in self.inputs and len(self.inputs['x0'].links) > 0:
inputsocketname = self.inputs[0].name
outputsocketname = [
'data',
]
changable_sockets(self, inputsocketname, outputsocketname)
if 'data' in self.outputs and len(self.outputs['data'].links) > 0:
if 'x0' in self.inputs and len(self.inputs['x0'].links) > 0:
X = SvGetSocketAnyType(self, self.inputs['data'])
slots = []
for socket in self.inputs:
if socket.links:
slots.append(SvGetSocketAnyType(self, socket))
if len(slots) < 2:
return
X_ = dataCorrect(X)
result = []
for socket in slots:
result.extend(self.f(X_, dataCorrect(socket)))
SvSetSocketAnyType(self, 'data', result)
def process(self):
# inputs
if 'Vertices' in self.inputs and self.inputs['Vertices'].is_linked:
Vertices = SvGetSocketAnyType(self, self.inputs['Vertices'])
else:
Vertices = []
if 'Vert A' in self.inputs and self.inputs['Vert A'].is_linked:
Vert_A = SvGetSocketAnyType(self, self.inputs['Vert A'])[0]
else:
Vert_A = [[0.0, 0.0, 0.0]]
if 'Vert B' in self.inputs and self.inputs['Vert B'].is_linked:
Vert_B = SvGetSocketAnyType(self, self.inputs['Vert B'])[0]
else:
Vert_B = [[1.0, 0.0, 0.0]]
if 'Plane' in self.inputs and self.inputs['Plane'].is_linked:
Plane = SvGetSocketAnyType(self, self.inputs['Plane'])
else:
Plane = [Matrix()]
# outputs
if 'Vertices' in self.outputs and self.outputs['Vertices'].is_linked:
if self.mode == 'VERTEX':
parameters = match_long_repeat([Vertices, Vert_A])
points = [mirrorPoint(v, a) for v, a in zip(*parameters)]
SvSetSocketAnyType(self, 'Vertices', points)
elif self.mode == 'AXIS':
parameters = match_long_repeat([Vertices, Vert_A, Vert_B])
points = [mirrorAxis(v, a, b) for v, a, b in zip(*parameters)]
SvSetSocketAnyType(self, 'Vertices', points)
elif self.mode == 'PLANE':
parameters = match_long_repeat([Vertices, Plane])
points = [mirrorPlane(v, p) for v, p in zip(*parameters)]
SvSetSocketAnyType(self, 'Vertices', points)
def process(self):
# inputs
if 'vecs X' in self.inputs and self.inputs['vecs X'].is_linked:
IntegerX = min(int(SvGetSocketAnyType(self, self.inputs['vecs X'])[0][0]), 100)
else:
IntegerX = int(self.Xvecs)
if 'vecs Y' in self.inputs and self.inputs['vecs Y'].is_linked:
IntegerY = min(int(SvGetSocketAnyType(self, self.inputs['vecs Y'])[0][0]), 100)
else:
IntegerY = int(self.Yvecs)
if 'Step X' in self.inputs and self.inputs['Step X'].is_linked:
StepX = SvGetSocketAnyType(self, self.inputs['Step X'])[0]
fullList(StepX, IntegerX)
else:
StepX = [self.Xstep]
fullList(StepX, IntegerX)
if 'Step Y' in self.inputs and self.inputs['Step Y'].is_linked:
StepY = SvGetSocketAnyType(self, self.inputs['Step Y'])[0]
fullList(StepY, IntegerY)
else:
StepY = [self.Ystep]
fullList(StepY, IntegerY)
# outputs
if 'vecs' in self.outputs and self.outputs['vecs'].is_linked:
out = self.make_vertices(IntegerX-1, IntegerY-1, StepX, StepY, self.name_image)
SvSetSocketAnyType(self, 'vecs', [out])
else:
SvSetSocketAnyType(self, 'vecs', [[[]]])
if 'edgs' in self.outputs and len(self.outputs['edgs'].is_linked) > 0:
listEdg = []
for i in range(IntegerY):
for j in range(IntegerX-1):
listEdg.append((IntegerX*i+j, IntegerX*i+j+1))
for i in range(IntegerX):
for j in range(IntegerY-1):
listEdg.append((IntegerX*j+i, IntegerX*j+i+IntegerX))
edg = list(listEdg)
SvSetSocketAnyType(self, 'edgs', [edg])
else:
SvSetSocketAnyType(self, 'edgs', [[[]]])
if 'pols' in self.outputs and self.outputs['pols'].is_linked:
listPlg = []
for i in range(IntegerX-1):
for j in range(IntegerY-1):
listPlg.append((IntegerX*j+i, IntegerX*j+i+1, IntegerX*j+i+IntegerX+1, IntegerX*j+i+IntegerX))
plg = list(listPlg)
SvSetSocketAnyType(self, 'pols', [plg])
else:
SvSetSocketAnyType(self, 'pols', [[[]]])
def process(self):
if 'vertices' in self.inputs and self.inputs['vertices'].is_linked and \
'edges' in self.inputs and self.inputs['edges'].is_linked:
verts = dataCorrect(
SvGetSocketAnyType(self, self.inputs['vertices']))
edges = dataCorrect(SvGetSocketAnyType(self, self.inputs['edges']))
sides = repeat_last(self.inputs['Sides'].sv_get()[0])
verts_out = []
edges_out = []
polys_out = []
for v, e, s in zip(verts, edges, sides):
res = fill_holes(v, e, int(s))
if not res:
return
verts_out.append(res[0])
edges_out.append(res[1])
polys_out.append(res[2])
if 'vertices' in self.outputs and self.outputs[
'vertices'].is_linked:
SvSetSocketAnyType(self, 'vertices', verts_out)
if 'edges' in self.outputs and self.outputs['edges'].is_linked:
SvSetSocketAnyType(self, 'edges', edges_out)
if 'polygons' in self.outputs and self.outputs[
'polygons'].is_linked:
SvSetSocketAnyType(self, 'polygons', polys_out)
def process(self):
# достаём два слота - вершины и полики
if 'Centers' in self.outputs and self.outputs[
'Centers'].links or self.outputs['Normals'].links:
if 'Polygons' in self.inputs and 'Vertices' in self.inputs and self.inputs[
'Polygons'].links and self.inputs['Vertices'].links:
#if type(self.inputs['Poligons'].links[0].from_socket) == StringsSocket:
pols = SvGetSocketAnyType(self, self.inputs['Polygons'])
#if type(self.inputs['Vertices'].links[0].from_socket) == VerticesSocket:
vers = SvGetSocketAnyType(self, self.inputs['Vertices'])
normalsFORout = []
for i, obj in enumerate(vers):
mesh_temp = bpy.data.meshes.new('temp')
mesh_temp.from_pydata(obj, [], pols[i])
mesh_temp.update(calc_edges=True)
tempobj = []
for v in mesh_temp.vertices:
tempobj.append(v.normal[:])
normalsFORout.append(tempobj)
bpy.data.meshes.remove(mesh_temp)
#print (normalsFORout)
if 'Normals' in self.outputs and self.outputs['Normals'].links:
SvSetSocketAnyType(self, 'Normals', normalsFORout)
def process(self):
# inputs
if self.inputs['Radius'].is_linked:
Radius = SvGetSocketAnyType(self, self.inputs['Radius'])[0]
else:
Radius = [self.rad_]
if self.inputs['Nº Vertices'].is_linked:
Vertices = SvGetSocketAnyType(self, self.inputs['Nº Vertices'])[0]
Vertices = list(map(lambda x: max(3, int(x)), Vertices))
else:
Vertices = [self.vert_]
if self.inputs['Degrees'].is_linked:
Angle = SvGetSocketAnyType(self, self.inputs['Degrees'])[0]
Angle = list(map(lambda x: min(360, max(0, x)), Angle))
else:
# okay this is silly but since the rest was written before this gave degrees.
Angle = [degrees(self.degr_)]
parameters = match_long_repeat([Angle, Vertices, Radius])
# outputs
if self.outputs['Vertices'].is_linked:
points = [self.make_verts(a, v, r) for a, v, r in zip(*parameters)]
SvSetSocketAnyType(self, 'Vertices', points)
if self.outputs['Edges'].is_linked:
edg = [self.make_edges(v, a) for a, v, r in zip(*parameters)]
SvSetSocketAnyType(self, 'Edges', edg)
if self.outputs['Polygons'].is_linked:
plg = [self.make_faces(a, v) for a, v, r in zip(*parameters)]
SvSetSocketAnyType(self, 'Polygons', plg)
def process(self):
if self.inputs['vertices1'].is_linked and self.inputs[
'vertices2'].is_linked:
prop1_ = SvGetSocketAnyType(self, self.inputs['vertices1'])
prop1 = Vector_generate(prop1_)
prop2_ = SvGetSocketAnyType(self, self.inputs['vertices2'])
prop2 = Vector_generate(prop2_)
elif self.inputs['matrix1'].is_linked and self.inputs[
'matrix2'].is_linked:
propa = SvGetSocketAnyType(self, self.inputs['matrix1'])
prop1 = Matrix_location(Matrix_generate(propa))
propb = SvGetSocketAnyType(self, self.inputs['matrix2'])
prop2 = Matrix_location(Matrix_generate(propb))
else:
prop1, prop2 = [], []
if prop1 and prop2:
if self.outputs['distances'].is_linked:
#print ('distances input', str(prop1), str(prop2))
if self.Cross_dist:
output = self.calcM(prop1, prop2)
else:
output = self.calcV(prop1, prop2)
SvSetSocketAnyType(self, 'distances', output)
#print ('distances out' , str(output))
else:
SvSetSocketAnyType(self, 'distances', [])
def process(self):
# inputs
if 'Start' in self.inputs and self.inputs['Start'].links:
tmp = SvGetSocketAnyType(self, self.inputs['Start'])
Start = tmp[0][0]
else:
Start = self.start_
if 'Stop' in self.inputs and self.inputs['Stop'].links:
tmp = SvGetSocketAnyType(self, self.inputs['Stop'])
Stop = tmp[0][0]
else:
Stop = self.stop_
if 'Step' in self.inputs and self.inputs['Step'].links:
tmp = SvGetSocketAnyType(self, self.inputs['Step'])
Step = tmp[0][0]
else:
Step = self.step_
# outputs
if 'Series' in self.outputs and len(self.outputs['Series'].links) > 0:
#print (Start, Stop, Step)
if Step < 0:
Step = 1
if Stop < Start:
Stop = Start + 1
series = [c for c in self.xfrange(Start, Stop, Step)]
SvSetSocketAnyType(self, 'Series', [series])
def process(self):
# inputs
if 'Start' in self.inputs and self.inputs['Start'].links:
tmp = SvGetSocketAnyType(self, self.inputs['Start'])
Start = tmp[0][0]
else:
Start = self.start_
if 'Stop' in self.inputs and self.inputs['Stop'].links:
tmp = SvGetSocketAnyType(self, self.inputs['Stop'])
Stop = tmp[0][0]
else:
Stop = self.stop_
if 'Divisions' in self.inputs and self.inputs['Divisions'].links:
tmp = SvGetSocketAnyType(self, self.inputs['Divisions'])
Divisions = tmp[0][0]
else:
Divisions = self.divisions_
# outputs
if 'Range' in self.outputs and self.outputs['Range'].links:
if Divisions < 2:
Divisions = 2
Range = [Start]
if Divisions > 2:
Range.extend([c for c in self.xfrange(Start, Stop, Divisions)])
Range.append(Stop)
SvSetSocketAnyType(self, 'Range', [Range])
def process(self):
# inputs
if 'vertices' in self.inputs and self.inputs['vertices'].links and \
type(self.inputs['vertices'].links[0].from_socket) == VerticesSocket:
vers_ = SvGetSocketAnyType(self, self.inputs['vertices'])
vers = Vector_generate(vers_)
else:
vers = []
if 'vectors' in self.inputs and self.inputs['vectors'].links and \
type(self.inputs['vectors'].links[0].from_socket) == VerticesSocket:
vecs_ = SvGetSocketAnyType(self, self.inputs['vectors'])
vecs = Vector_generate(vecs_)
else:
vecs = []
if 'multiplier' in self.inputs and self.inputs['multiplier'].links and \
type(self.inputs['multiplier'].links[0].from_socket) == StringsSocket:
mult = SvGetSocketAnyType(self, self.inputs['multiplier'])
else:
mult = [[self.mult_]]
# outputs
if 'vertices' in self.outputs and self.outputs['vertices'].links:
mov = self.moved(vers, vecs, mult)
SvSetSocketAnyType(self, 'vertices', mov)
def process(self):
if not ('Edges' in self.outputs):
return
# inputs
if self.outputs['Edges'].is_linked or self.outputs['Vertices'].is_linked:
if self.inputs['Level'].is_linked:
Integer = int(SvGetSocketAnyType(self, self.inputs['Level'])[0][0])
else:
Integer = self.level_
if self.inputs['Size'].is_linked:
Step = SvGetSocketAnyType(self, self.inputs['Size'])[0][0]
else:
Step = self.size_
# outputs
if self.outputs['Vertices'].is_linked:
verts = self.hilbert(Step, Integer)
SvSetSocketAnyType(self, 'Vertices', verts)
if self.outputs['Edges'].is_linked:
listEdg = []
r = len(verts[0])-1
for i in range(r):
listEdg.append((i, i+1))
edg = list(listEdg)
SvSetSocketAnyType(self, 'Edges', [edg])
def process(self):
# inputs
if 'Count' in self.inputs and self.inputs['Count'].links and \
type(self.inputs['Count'].links[0].from_socket) == bpy.types.StringsSocket:
Coun = SvGetSocketAnyType(self, self.inputs['Count'])[0]
else:
Coun = [self.count_inner]
if 'Seed' in self.inputs and self.inputs['Seed'].links and \
type(self.inputs['Seed'].links[0].from_socket) == bpy.types.StringsSocket:
Seed = SvGetSocketAnyType(self, self.inputs['Seed'])[0]
else:
Seed = [self.seed]
# outputs
if 'Random' in self.outputs and self.outputs['Random'].links:
Random = []
param = match_long_repeat([Coun, Seed])
# set seed, protect against float input
# seed = 0 is special value for blender which unsets the seed value
# and starts to use system time making the random values unrepeatable.
# So when seed = 0 we use a random value far from 0, generated used random.org
for c, s in zip(*param):
int_seed = int(round(s))
if int_seed:
seed_set(int_seed)
else:
seed_set(140230)
Random.append([
random_unit_vector().to_tuple()
for i in range(int(max(1, c)))
])
SvSetSocketAnyType(self, 'Random', Random)
def process(self):
if 'Item' in self.outputs and self.outputs['Item'].is_linked or \
'Other' in self.outputs and self.outputs['Other'].is_linked:
if 'Data' in self.inputs and self.inputs['Data'].is_linked:
data = SvGetSocketAnyType(self, self.inputs['Data'])
if 'Item' in self.inputs and self.inputs['Item'].is_linked:
items = SvGetSocketAnyType(self, self.inputs['Item'])
else:
items = [[self.item]]
if 'Item' in self.outputs and self.outputs['Item'].is_linked:
if self.level - 1:
out = self.get(data, self.level - 1, items,
self.get_items)
else:
out = self.get_items(data, items[0])
SvSetSocketAnyType(self, 'Item', out)
if 'Other' in self.outputs and self.outputs['Other'].is_linked:
if self.level - 1:
out = self.get(data, self.level - 1, items,
self.get_other)
else:
out = self.get_other(data, items[0])
SvSetSocketAnyType(self, 'Other', out)
def process(self):
# inputs
if 'vertices' in self.outputs and self.outputs['vertices'].is_linked or \
'edg_pol' in self.outputs and self.outputs['edg_pol'].is_linked:
if 'vertices' in self.inputs and self.inputs['vertices'].is_linked and \
'edg_pol' in self.inputs and self.inputs['edg_pol'].is_linked:
vertices = SvGetSocketAnyType(self, self.inputs['vertices'])
edgs_pols = SvGetSocketAnyType(self, self.inputs['edg_pol'])
else:
return
vert_out = []
edpo_out = []
for k, ob in enumerate(edgs_pols):
for ep in ob:
new_vers = []
new_edpo = []
for i, index in enumerate(ep):
new_vers.append(vertices[k][index])
new_edpo.append(i)
vert_out.append(new_vers)
edpo_out.append([new_edpo])
if 'vertices' in self.outputs and self.outputs[
'vertices'].is_linked:
SvSetSocketAnyType(self, 'vertices', vert_out)
if 'edg_pol' in self.outputs and self.outputs['edg_pol'].is_linked:
SvSetSocketAnyType(self, 'edg_pol', edpo_out)
def process(self):
# inputs
if self.inputs['Radius'].links:
Radius = SvGetSocketAnyType(self, self.inputs['Radius'])[0]
else:
Radius = [self.rad_]
if self.inputs['Nº Vertices'].links:
Vertices = SvGetSocketAnyType(self, self.inputs['Nº Vertices'])[0]
Vertices = list(map(lambda x: max(3, int(x)), Vertices))
else:
Vertices = [self.vert_]
if self.inputs['Degrees'].links:
Angle = SvGetSocketAnyType(self, self.inputs['Degrees'])[0]
Angle = list(map(lambda x: min(360, max(0, x)), Angle))
else:
Angle = [self.degr_]
parameters = match_long_repeat([Angle, Vertices, Radius])
if self.outputs['Vertices'].links:
points = [self.make_verts(a, v, r) for a, v, r in zip(*parameters)]
SvSetSocketAnyType(self, 'Vertices', points)
if self.outputs['Edges'].links:
edg = [self.make_edges(v, a) for a, v, r in zip(*parameters)]
SvSetSocketAnyType(self, 'Edges', edg)
if self.outputs['Polygons'].links:
plg = [self.make_faces(a, v) for a, v, r in zip(*parameters)]
SvSetSocketAnyType(self, 'Polygons', plg)
def process(self):
global cache_viewer_baker
# node id, used as ref
n_id = node_id(self)
if 'matrix' not in self.inputs:
return
cache_viewer_baker[n_id + 'v'] = []
cache_viewer_baker[n_id + 'ep'] = []
cache_viewer_baker[n_id + 'm'] = []
if not self.id_data.sv_show:
callback_disable(n_id)
return
if self.activate and (self.inputs['vertices'].links
or self.inputs['matrix'].links):
callback_disable(n_id)
if self.inputs['vertices'].links and \
type(self.inputs['vertices'].links[0].from_socket) == VerticesSocket:
propv = SvGetSocketAnyType(self, self.inputs['vertices'])
cache_viewer_baker[n_id + 'v'] = dataCorrect(propv)
else:
cache_viewer_baker[n_id + 'v'] = []
if self.inputs['edg_pol'].links and \
type(self.inputs['edg_pol'].links[0].from_socket) == StringsSocket:
prope = SvGetSocketAnyType(self, self.inputs['edg_pol'])
cache_viewer_baker[n_id + 'ep'] = dataCorrect(prope)
#print (prope)
else:
cache_viewer_baker[n_id + 'ep'] = []
if self.inputs['matrix'].links and \
type(self.inputs['matrix'].links[0].from_socket) == MatrixSocket:
propm = SvGetSocketAnyType(self, self.inputs['matrix'])
cache_viewer_baker[n_id + 'm'] = dataCorrect(propm)
else:
cache_viewer_baker[n_id + 'm'] = []
else:
callback_disable(n_id)
if cache_viewer_baker[n_id + 'v'] or cache_viewer_baker[n_id + 'm']:
callback_enable(n_id, cache_viewer_baker[n_id+'v'], cache_viewer_baker[n_id+'ep'], \
cache_viewer_baker[n_id+'m'], self.Vertex_show, self.color_view.copy(), self.transparant, self.shading)
self.use_custom_color = True
self.color = (1, 0.3, 0)
else:
self.use_custom_color = True
self.color = (0.1, 0.05, 0)
#print ('отражения вершин ',len(cache_viewer_baker['v']), " рёбёры ", len(cache_viewer_baker['ep']), "матрицы",len(cache_viewer_baker['m']))
if not self.inputs['vertices'].links and not self.inputs[
'matrix'].links:
callback_disable(n_id)
def process(self):
if not all((s.is_linked for s in self.inputs)):
return
if not any((s.is_linked for s in self.outputs)):
return
versR = Vector_generate(SvGetSocketAnyType(self, self.inputs['VersR']))
versD = Vector_generate(SvGetSocketAnyType(self, self.inputs['VersD']))
edgeR = SvGetSocketAnyType(self, self.inputs['EdgeR'])
edgeD = SvGetSocketAnyType(self, self.inputs['EdgeD'])
verts_out = []
edges_out = []
mesh_join = self.mesh_join
# only first obj
verD = [v - versD[0][0] for v in versD[0]]
edgD = edgeD[0]
d_vector = verD[-1].copy()
d_scale = d_vector.length
d_vector.normalize()
for vc, edg in zip(versR, edgeR):
if mesh_join:
v_out = []
v_out_app = v_out.append
e_out = []
e_out_app = e_out.append
for e in edg:
if not mesh_join:
v_out = []
v_out_app = v_out.append
e_vector = vc[e[1]] - vc[e[0]]
e_scale = e_vector.length
e_vector.normalize()
q1 = d_vector.rotation_difference(e_vector)
mat_s = Matrix.Scale(e_scale / d_scale, 4)
mat_r = Matrix.Rotation(q1.angle, 4, q1.axis)
mat_l = Matrix.Translation(vc[e[0]])
mat = mat_l * mat_r * mat_s
offset = len(v_out)
for v in verD:
v_out_app((mat * v)[:])
if mesh_join:
for edge in edgD:
e_out_app([i + offset for i in edge])
else:
verts_out.append(v_out)
edges_out.append(edgD)
if mesh_join:
verts_out.append(v_out)
edges_out.append(e_out)
if 'Vertices' in self.outputs and self.outputs['Vertices'].is_linked:
SvSetSocketAnyType(self, 'Vertices', verts_out)
if 'Edges' in self.outputs and self.outputs['Edges'].is_linked:
SvSetSocketAnyType(self, 'Edges', edges_out)
def get_data(self):
out = ""
if self.text_mode == 'CSV':
data_out = []
for socket in self.inputs:
if socket.links and \
type(socket.links[0].from_socket) == StringsSocket:
tmp = SvGetSocketAnyType(self, socket)
if tmp:
# flatten list
data_out.extend(
list(itertools.chain.from_iterable([tmp])))
csv_str = io.StringIO()
writer = csv.writer(csv_str, dialect=self.csv_dialect)
for row in zip(*data_out):
writer.writerow(row)
out = csv_str.getvalue()
elif self.text_mode == 'JSON':
data_out = {}
name_dict = {'m': 'Matrix', 's': 'Data', 'v': 'Vertices'}
for socket in self.inputs:
if socket.links:
tmp = SvGetSocketAnyType(self, socket)
if tmp:
tmp_name = socket.links[
0].from_node.name + ':' + socket.links[
0].from_socket.name
name = tmp_name
j = 1
while name in data_out: # unique names for json
name = tmp_name + str(j)
j += 1
data_out[name] = (get_socket_type(self,
socket.name), tmp)
if self.json_mode == 'pretty':
out = json.dumps(data_out, indent=4)
else: # compact
out = json.dumps(data_out, separators=(',', ':'))
elif self.text_mode == 'SV':
if self.inputs['Data'].links:
data = SvGetSocketAnyType(self, self.inputs['Data'])
if self.sv_mode == 'pretty':
out = pprint.pformat(data)
else: # compact
out = str(data)
return out
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):
if all((s.is_linked for s in self.inputs[1:])):
if self.inputs['Mask'].is_linked:
mask = SvGetSocketAnyType(self, self.inputs['Mask'])
else: # to match MaskList
mask = [[1, 0]]
data_t = SvGetSocketAnyType(self, self.inputs['Data True'])
data_f = SvGetSocketAnyType(self, self.inputs['Data False'])
data_out = self.get_level(mask, data_t, data_f, self.level - 1)
SvSetSocketAnyType(self, 'Data', data_out)
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):
# check if running during startup, cancel if True
try:
l = bpy.data.node_groups[self.id_data.name]
except Exception as e:
print("Bakery cannot run during startup", e)
return
if self.inputs['vertices'].links and self.inputs[
'edg_pol'].links and self.activate:
if 'vertices' in self.inputs and self.inputs['vertices'].links and \
type(self.inputs['vertices'].links[0].from_socket) == VerticesSocket:
propv = SvGetSocketAnyType(self, self.inputs['vertices'])
vertices = dataCorrect(propv, nominal_dept=2)
else:
vertices = []
if 'edg_pol' in self.inputs and self.inputs['edg_pol'].links and \
type(self.inputs['edg_pol'].links[0].from_socket) == StringsSocket:
prope = SvGetSocketAnyType(self, self.inputs['edg_pol'])
edges = dataCorrect(prope)
else:
edges = []
if 'matrix' in self.inputs and self.inputs['matrix'].links and \
type(self.inputs['matrix'].links[0].from_socket) == MatrixSocket:
propm = SvGetSocketAnyType(self, self.inputs['matrix'])
matrices = dataCorrect(propm)
else:
matrices = []
if vertices and edges:
for i in vertices:
matrices.append(Matrix())
if vertices and edges:
self.makeobjects(vertices, edges, matrices)
self.use_custom_color = True
self.color = (1, 0.3, 0)
else:
self.use_custom_color = True
self.color = (0.1, 0.05, 0)
for obj in bpy.context.scene.objects:
nam = 'Sv_' + self.name
if nam in obj.name:
bpy.context.scene.objects[obj.name].select = True
bpy.ops.object.delete(use_global=False)
global sverchok_bakery_cache
sverchok_bakery_cache[self.name] = []
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 = SvGetSocketAnyType(self, self.inputs['Vertices'])
poly_edge = SvGetSocketAnyType(self, self.inputs['PolyEdge'])
verts_out = []
poly_edge_out = []
for ve, pe in zip(verts, poly_edge):
# trying to remove indeces of polygons that more that length of
# vertices list. But it doing wrong, ideces not mutch vertices...
# what am i doing wrong?
# i guess, i didn't understood this iterations at all
delp = []
for p in pe:
deli = []
for i in p:
if i >= len(ve):
deli.append(i)
if deli and (len(p) - len(deli)) >= 2:
print(deli)
for k in deli:
p.remove(k)
elif (len(p) - len(deli)) <= 1:
delp.append(p)
if delp:
for d in delp:
pe.remove(d)
indx = set(chain.from_iterable(pe))
verts_out.append([v for i, v in enumerate(ve) if i in indx])
v_index = dict([(j, i) for i, j in enumerate(sorted(indx))])
poly_edge_out.append(
[list(map(lambda n: v_index[n], p)) for p in pe])
if 'Vertices' in self.outputs and self.outputs[
'Vertices'].is_linked:
SvSetSocketAnyType(self, 'Vertices', verts_out)
if 'PolyEdge' in self.outputs and self.outputs[
'PolyEdge'].is_linked:
if poly_edge_out:
SvSetSocketAnyType(self, 'PolyEdge', poly_edge_out)
else:
SvSetSocketAnyType(self, 'PolyEdge', [[[]]])
def xml_text_format(self):
"""
substitute constants from xml
and variables from socket inputs
"""
# get constants from xml
format_dict = {}
if not hasattr(self, 'xml_text'):
return
for elem in self.xml_tree.findall("constants"):
format_dict.update(elem.attrib)
# add input socket values to constants dict
for socket in self.inputs[1:]:
if socket.is_linked:
format_dict[socket.name] = SvGetSocketAnyType(self,
socket)[0][0]
else:
format_dict[socket.name] = 0
while '{' in self.xml_text:
# using while loop
# allows constants to be defined using other constants
self.xml_text = self.xml_text.format(**format_dict)
self.xml_tree = fromstring(self.xml_text)
def process(self):
if not self.outputs['Polygons'].is_linked:
return
verts = Vector_generate(
SvGetSocketAnyType(self, self.inputs['Vertices']))
faces = self.inputs['Polygons'].sv_get()
if not (len(verts) == len(faces)):
return
verts_out = []
polys_out = []
for v_obj, f_obj in zip(verts, faces):
res = join_tris(v_obj, f_obj, self.limit)
if not res:
return
verts_out.append(res[0])
polys_out.append(res[1])
if self.outputs['Vertices'].is_linked:
SvSetSocketAnyType(self, 'Vertices', verts_out)
SvSetSocketAnyType(self, 'Polygons', polys_out)
def process(self):
if not self.inputs['Vertices'].is_linked:
return
if not any([s.is_linked for s in self.outputs]):
return
has_mat_out = bool(self.outputs['Center'].is_linked)
has_mean = bool(self.outputs['Mean'].is_linked)
has_vert_out = bool(self.outputs['Vertices'].is_linked)
vert = SvGetSocketAnyType(self, self.inputs['Vertices'])
vert = dataCorrect(vert, nominal_dept=2)
if vert:
verts_out = []
edges_out = []
edges = [
(0, 1),
(1, 3),
(3, 2),
(2, 0), # bottom edges
(4, 5),
(5, 7),
(7, 6),
(6, 4), # top edges
(0, 4),
(1, 5),
(2, 6),
(3, 7) # sides
]
mat_out = []
mean_out = []
for v in vert:
if has_mat_out or has_vert_out:
maxmin = list(zip(map(max, *v), map(min, *v)))
out = list(product(*reversed(maxmin)))
verts_out.append([l[::-1] for l in out[::-1]])
edges_out.append(edges)
if has_mat_out:
center = [(u + v) * .5 for u, v in maxmin]
mat = Matrix.Translation(center)
scale = [(u - v) * .5 for u, v in maxmin]
for i, s in enumerate(scale):
mat[i][i] = s
mat_out.append(mat)
if has_mean:
avr = list(map(sum, zip(*v)))
avr = [n / len(v) for n in avr]
mean_out.append([avr])
if self.outputs['Vertices'].is_linked:
SvSetSocketAnyType(self, 'Vertices', verts_out)
if self.outputs['Edges'].is_linked:
SvSetSocketAnyType(self, 'Edges', edges_out)
if self.outputs['Mean'].is_linked:
SvSetSocketAnyType(self, 'Mean', mean_out)
if self.outputs['Center'].is_linked:
SvSetSocketAnyType(self, 'Center', Matrix_listing(mat_out))
def process(self):
if 'Matrix' in self.inputs and self.inputs['Matrix'].is_linked:
matrixes_ = SvGetSocketAnyType(self, self.inputs['Matrix'])
matrixes = Matrix_generate(matrixes_)
if 'Location' in self.outputs and self.outputs[
'Location'].is_linked:
locs = Matrix_location(matrixes, list=True)
SvSetSocketAnyType(self, 'Location', locs)
if 'Scale' in self.outputs and self.outputs['Scale'].is_linked:
locs = Matrix_scale(matrixes, list=True)
SvSetSocketAnyType(self, 'Scale', locs)
if ('Rotation' in self.outputs and self.outputs['Rotation'].is_linked) \
or ('Angle' in self.outputs and self.outputs['Angle'].is_linked):
locs = Matrix_rotation(matrixes, list=True)
rots = []
angles = []
for lists in locs:
rots.append([pair[0] for pair in lists])
for pair in lists:
angles.append(degrees(pair[1]))
SvSetSocketAnyType(self, 'Rotation', rots)
SvSetSocketAnyType(self, 'Angle', [angles])
else:
matrixes = [[]]
def update(self):
# inputs
if len(self.outputs['Edges'].links) > 0 or len(
self.outputs['Vertices'].links) > 0:
if len(self.inputs['Level'].links) > 0:
Integer = int(
SvGetSocketAnyType(self, self.inputs['Level'])[0][0])
else:
Integer = self.level_
if len(self.inputs['Size'].links) > 0:
Step = eval(self.inputs['Size'].links[0].from_socket.
StringsProperty)[0][0]
else:
Step = self.size_
# outputs
if 'Vertices' in self.outputs and len(
self.outputs['Vertices'].links) > 0:
verts = self.hilbert(0.0, 0.0, Step * 1.0, 0.0, 0.0, Step * 1.0,
Integer)
self.outputs['Vertices'].VerticesProperty = str([verts])
if 'Edges' in self.outputs and len(self.outputs['Edges'].links) > 0:
listEdg = []
r = len(verts) - 1
for i in range(r):
listEdg.append((i, i + 1))
edg = list(listEdg)
self.outputs['Edges'].StringsProperty = str([edg])
def process(self):
# check inputs and that there is at least one output
func_dict = {
'SHORT': match_short,
'CYCLE': match_long_cycle,
'REPEAT': match_long_repeat,
'XREF': match_cross2
}
count_inputs = sum(s.is_linked for s in self.inputs)
count_outputs = sum(s.is_linked for s in self.outputs)
if count_inputs == len(self.inputs) - 1 and count_outputs:
out = []
lsts = []
# get data
for socket in self.inputs:
if socket.is_linked:
lsts.append(SvGetSocketAnyType(self, socket))
out = self.match(lsts, self.level, func_dict[self.mode],
func_dict[self.mode_final])
# output into linked sockets s
for i, socket in enumerate(self.outputs):
if i == len(out): # never write to last socket
break
if socket.is_linked:
SvSetSocketAnyType(self, socket.name, out[i])
def process(self):
if self.inputs['data'].is_linked and self.outputs['data'].is_linked:
outEval = SvGetSocketAnyType(self, self.inputs['data'])
#outCorr = dataCorrect(outEval) # this is bullshit, as max 3 in levels
levels = self.level - 1
out = flip(outEval, levels)
SvSetSocketAnyType(self, 'data', out)
def process(self):
if 'Vertices' not in self.outputs:
return
if not any((s.is_linked for s in self.outputs)):
return
if self.inputs['Vertices'].is_linked:
verts = SvGetSocketAnyType(self, self.inputs['Vertices'])
verts = dataCorrect(verts)
t_ins = self.inputs['Interval'].sv_get()
verts_out = []
for v, t_in in zip(verts, repeat_last(t_ins)):
pts = np.array(v).T
tmp = np.apply_along_axis(np.linalg.norm, 0,
pts[:, :-1] - pts[:, 1:])
t = np.insert(tmp, 0, 0).cumsum()
t = t / t[-1]
t_corr = [min(1, max(t_c, 0)) for t_c in t_in]
# this should also be numpy
if self.mode == 'LIN':
out = [np.interp(t_corr, t, pts[i]) for i in range(3)]
verts_out.append(list(zip(*out)))
else: # SPL
spl = cubic_spline(v, t)
out = eval_spline(spl, t, t_corr)
verts_out.append(out)
if 'Vertices' in self.outputs and self.outputs[
'Vertices'].is_linked:
SvSetSocketAnyType(self, 'Vertices', verts_out)
def process(self):
outputs = self.outputs
'''
- is hnd_edges socket created, means all sockets exist.
- is anything connected to the Verts socket?
'''
if not (('hnd Edges' in outputs) and (outputs['Verts'].links)):
return
'''
operational scheme: (spline = handle set (k1, ctrl1, ctrl2, k2))
- num_vert can be given per spline
- if no num_vert is given, default is used for all splines
- if node receives more splines than items in num_vert list, last is re-used.
- each (k1 ctrl1 ctrl2 k2) must have input
- the length of (k1 ctrl1 ctrl2 k2) individually must be equal (no last used)
'''
inputs = self.inputs
handle_names = ['knot_1', 'ctrl_1', 'ctrl_2', 'knot_2']
if not all([inputs[p].links for p in handle_names]):
return
# assume they all match, reduce cycles used for checking.
handle_sockets = (inputs[handle_names[i]] for i in range(4))
handle_data = []
for socket in handle_sockets:
v = []
if isinstance(socket.links[0].from_socket, VerticesSocket):
v = SvGetSocketAnyType(self, socket, deepcopy=False)[0]
handle_data.append(v)
knots_1, ctrls_1, ctrls_2, knots_2 = handle_data
if not (len(knots_1) == len(ctrls_1) == len(ctrls_2) == len(knots_2)):
return
# get vert_nums, or pad till matching quantity
nv = []
nv_links = inputs['num_verts'].links
if nv_links:
if isinstance(nv_links[0].from_socket, StringsSocket):
nv = SvGetSocketAnyType(self, inputs['num_verts'], deepcopy=False)[0]
if nv and (len(nv) < len(knots_1)):
pad_num = len(knots_1) - len(nv)
for i in range(pad_num):
nv.append(nv[-1])
else:
for i in range(len(knots_1)):
nv.append(self.num_verts)
# iterate over them
verts_out = []
edges_out = []
h_verts_out = []
h_edges_out = []
for idx, handle_set in enumerate(zip(knots_1, ctrls_1, ctrls_2, knots_2)):
divisions = nv[idx] if idx < len(nv) else 3
v, e = generate_bezier(handle_set, divisions)
verts_out.append(v)
edges_out.append(e)
# for visual
h_verts_out.append(handle_set)
h_edges_out.append([(0, 1), (2, 3)])
# reaches here if we got usable data.
SvSetSocketAnyType(self, 'Verts', verts_out)
if outputs['Edges'].links:
SvSetSocketAnyType(self, 'Edges', edges_out)
# optional, show handles. this is useful for visual debug.
if outputs['hnd Verts'].links:
SvSetSocketAnyType(self, 'hnd Verts', h_verts_out)
if outputs['hnd Edges'].links:
SvSetSocketAnyType(self, 'hnd Edges', h_edges_out)
