def process(self): if self.inputs['vertices1'].is_linked and self.inputs['vertices2'].is_linked: prop1_ = self.inputs['vertices1'].sv_get() prop1 = Vector_generate(prop1_) prop2_ = self.inputs['vertices2'].sv_get() prop2 = Vector_generate(prop2_) elif self.inputs['matrix1'].is_linked and self.inputs['matrix2'].is_linked: propa = self.inputs['matrix1'].sv_get() prop1 = Matrix_location(Matrix_generate(propa)) propb = self.inputs['matrix2'].sv_get() 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) self.outputs['distances'].sv_set(output) # print ('distances out' , str(output)) else: self.outputs['distances'].sv_set([])
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): outputs = self.outputs if not outputs['C'].is_linked: return inputs = self.inputs id_mat = Matrix_listing([Matrix.Identity(4)]) A = Matrix_generate(inputs['A'].sv_get(default=id_mat)) if self.operation in {"MULTIPLY"}: # two matrix inputs available B = Matrix_generate(inputs['B'].sv_get(default=id_mat)) if self.prePost == "PRE": parameters = match_long_repeat([A, B]) else: parameters = match_long_repeat([B, A]) else: # one matrix input available parameters = [A] operation = self.get_operation() matrixList = [] for params in zip(*parameters): c = operation(*params) matrixList.append(c) matrices = Matrix_listing(matrixList) outputs['C'].sv_set(matrices)
def process(self): if not self.outputs['Vertices'].is_linked: return vertices = self.inputs['Vertices'].sv_get() vertices = Vector_generate(vertices) edges = self.inputs['Edges'].sv_get(default=[[]]) faces = self.inputs['Faces'].sv_get(default=[[]]) matrices = self.inputs['Matrices'].sv_get() matrices = Matrix_generate(matrices) n = len(matrices) result_vertices = self.apply(vertices, matrices) result_vertices = Vector_degenerate(result_vertices) self.outputs['Vertices'].sv_set(result_vertices) if self.outputs['Edges'].is_linked or self.outputs['Faces'].is_linked: result_edges = edges * n result_faces = faces * n if self.do_join: result_vertices, result_edges, result_faces = mesh_join( result_vertices, result_edges, result_faces) if self.outputs['Edges'].is_linked: self.outputs['Edges'].sv_set(result_edges) if self.outputs['Faces'].is_linked: self.outputs['Faces'].sv_set(result_faces)
def process(self): if not all([s.is_linked for s in self.inputs]): return if not self.outputs['vertices'].is_linked: return verts_ob = Vector_generate(self.inputs['vertices'].sv_get()) edg_pols = self.inputs['edg_pol'].sv_get() cut_mats_ = self.inputs['cut_matrix'].sv_get() cut_mats = Matrix_generate(cut_mats_) verts_out = [] edges_out = [] polys_out = [] for cut_mat in cut_mats: pp = cut_mat.to_translation() pno = Vector((0.0, 0.0, 1.0)) * cut_mat.to_3x3().transposed() for obj in zip(verts_ob, edg_pols): res = bisect(obj[0], obj[1], pp, pno, self.outer, self.inner, self.fill) if not res: return verts_out.append(res[0]) edges_out.append(res[1]) polys_out.append(res[2]) self.outputs['vertices'].sv_set(verts_out) self.outputs['edges'].sv_set(edges_out) self.outputs['polygons'].sv_set(polys_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 process(self): O, L, S, R, A = self.inputs Om = self.outputs[0] if Om.is_linked: if O.is_linked: orig = Matrix_generate(O.sv_get()) else: return if L.is_linked: loc = Vector_generate(L.sv_get()) else: loc = [[]] if S.is_linked: scale = Vector_generate(S.sv_get()) else: scale = [[]] if R.is_linked: rot = Vector_generate(R.sv_get()) else: rot = [[]] rotA, angle = [[]], [[0.0]] # ability to add vector & vector difference instead of only rotation values if A.is_linked: if A.links[0].from_socket.bl_idname == 'VerticesSocket': rotA = Vector_generate(A.sv_get()) angle = [[]] else: angle = A.sv_get() rotA = [[]] matrixes_ = matrixdef(orig, loc, scale, rot, angle, rotA) matrixes = Matrix_listing(matrixes_) Om.sv_set(matrixes)
def process(self): if not self.outputs['Vertices'].is_linked: return vertices = Vector_generate(self.inputs['Vertices'].sv_get()) matrices = Matrix_generate(self.inputs['Matrices'].sv_get()) verts_out, edges_out, faces_out = self.make_tube(matrices, vertices) self.outputs['Vertices'].sv_set([verts_out]) self.outputs['Edges'].sv_set([edges_out]) self.outputs['Faces'].sv_set([faces_out])
def makeobjects(self, vers, edg_pol, mats): # inception # fht = предохранитель от перебора рёбер и полигонов. fht = [] if len(edg_pol[0][0]) == 2: pols = [] for edgs in edg_pol: maxi = max(max(a) for a in edgs) fht.append(maxi) #print (maxi) elif len(edg_pol[0][0]) > 2: edgs = [] for pols in edg_pol: maxi = max(max(a) for a in pols) fht.append(maxi) #print (maxi) #print (fht) vertices = Vector_generate(vers) matrixes = Matrix_generate(mats) #print('mats' + str(matrixes)) objects = {} fhtagn = [] for u, f in enumerate(fht): fhtagn.append(min(len(vertices[u]), fht[u])) #lenmesh = len(vertices) - 1 #print ('запекание вершин ', vertices, " матрицы запекашка ", matrixes, " полиглоты ", edg_pol) #print (matrixes) for i, m in enumerate(matrixes): k = i lenver = len(vertices) - 1 if i > lenver: v = vertices[-1] k = lenver else: v = vertices[k] #print (fhtagn, len(v)-1) if (len(v) - 1) < fhtagn[k]: continue # возможно такая сложность не нужна, но пусть лежит тут. Удалять лишние точки не обязательно. elif fhtagn[k] < (len(v) - 1): nonneed = (len(v) - 1) - fhtagn[k] for q in range(nonneed): v.pop((fhtagn[k] + 1)) #print (fhtagn[k], (len(v)-1)) e = edg_pol[k] if edgs else [] p = edg_pol[k] if pols else [] objects[str(i)] = self.makemesh(i, v, e, p, m) for ite in objects.values(): me = ite[1] ob = ite[0] calcedg = True if edgs: calcedg = False me.update(calc_edges=calcedg) bpy.context.scene.objects.link(ob)
def get_data(name, fallback=[]): TypeSocket = get_socket_type(name) if has_good_link(name, TypeSocket): d = dataCorrect(inputs[name].sv_get()) if name == 'matrix': d = Matrix_generate(d) if d else [] elif name == 'vertices': d = Vector_generate(d) if d else [] return d return fallback
def process(self): # inputs if 'Matrix' in self.outputs and self.outputs['Matrix'].links: if self.inputs['Original'].links and \ type(self.inputs['Original'].links[0].from_socket) == MatrixSocket: orig_ = SvGetSocketAnyType(self, self.inputs['Original']) orig = Matrix_generate(orig_) else: return if 'Location' in self.inputs and self.inputs['Location'].links and \ type(self.inputs['Location'].links[0].from_socket) == VerticesSocket: loc_ = SvGetSocketAnyType(self, self.inputs['Location']) loc = Vector_generate(loc_) else: loc = [[]] if 'Scale' in self.inputs and self.inputs['Scale'].links and \ type(self.inputs['Scale'].links[0].from_socket) == VerticesSocket: scale_ = SvGetSocketAnyType(self, self.inputs['Scale']) scale = Vector_generate(scale_) else: scale = [[]] if 'Rotation' in self.inputs and self.inputs['Rotation'].links and \ type(self.inputs['Rotation'].links[0].from_socket) == VerticesSocket: rot_ = SvGetSocketAnyType(self, self.inputs['Rotation']) rot = Vector_generate(rot_) #print ('matrix_def', str(rot_)) else: rot = [[]] rotA = [[]] angle = [[0.0]] if 'Angle' in self.inputs and self.inputs['Angle'].links: if type(self.inputs['Angle'].links[0].from_socket ) == StringsSocket: angle = SvGetSocketAnyType(self, self.inputs['Angle']) elif type(self.inputs['Angle'].links[0].from_socket ) == VerticesSocket: rotA_ = SvGetSocketAnyType(self, self.inputs['Angle']) rotA = Vector_generate(rotA_) # outputs #print(loc) matrixes_ = matrixdef(orig, loc, scale, rot, angle, rotA) matrixes = Matrix_listing(matrixes_) SvSetSocketAnyType(self, 'Matrix', matrixes)
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 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 makeobjects(self, vers, edg_pol, mats): try: num_keys = len(edg_pol[0][0]) except: num_keys = 0 vertices = Vector_generate(vers) matrixes = Matrix_generate(mats) edgs, pols, max_vert_index, fht = [], [], [], [] if num_keys >= 2: for k in edg_pol: maxi = max(max(a) for a in k) fht.append(maxi) for u, f in enumerate(fht): max_vert_index.append(min(len(vertices[u]), fht[u])) objects = {} for i, m in enumerate(matrixes): k = i lenver = len(vertices) - 1 if i > lenver: v = vertices[-1] k = lenver else: v = vertices[k] if max_vert_index: if (len(v) - 1) < max_vert_index[k]: print('skipped object ', i, 'index out of bounds') print('largest available vertex index:', len(v) - 1, 'first larger reference:', max_vert_index[k]) continue elif max_vert_index[k] < (len(v) - 1): nonneed = (len(v) - 1) - max_vert_index[k] for q in range(nonneed): v.pop((max_vert_index[k] + 1)) e, p = [], [] if num_keys == 2: e = edg_pol[k] elif num_keys > 2: p = edg_pol[k] objects[str(i)] = self.makemesh(i, v, e, p, m) for ob, me in objects.values(): calcedg = False if (num_keys == 2) else True me.update(calc_edges=calcedg) bpy.context.scene.objects.link(ob)
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.outputs['Vectors'].is_linked: return vecs_ = self.inputs['Vectors'].sv_get() vecs = Vector_generate(vecs_) mats_ = dataCorrect(self.inputs['Matrixes'].sv_get()) mats = Matrix_generate(mats_) vectors = self.vecscorrect(vecs, mats) self.outputs['Vectors'].sv_set(vectors)
def process(self): empty = self.find_empty() if not empty: empty = self.create_empty() print("created new empty") if self.inputs['Matrix'].is_linked: mats = SvGetSocketAnyType(self, self.inputs['Matrix']) mat = Matrix_generate(mats)[0] else: mat = Matrix() self.label = empty.name empty.matrix_world = mat
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): # inputs if not self.outputs['C'].is_linked: return id_mat = Matrix_listing([Matrix.Identity(4)]) A = Matrix_generate(self.inputs['A'].sv_get(default=id_mat)) B = Matrix_generate(self.inputs['B'].sv_get(default=id_mat)) factor = self.inputs['Factor'].sv_get() matrixes_ = [] # match inputs, first matrix A and B using fullList # then extend the factor list if necessary, # A and B should control length of list, not interpolation lists max_l = max(len(A), len(B)) fullList(A, max_l) fullList(B, max_l) if len(factor) < max_l: fullList(factor, max_l) for i in range(max_l): for k in range(len(factor[i])): matrixes_.append(A[i].lerp(B[i], factor[i][k])) matrixes = Matrix_listing(matrixes_) self.outputs['C'].sv_set(matrixes)
def process(self): empty = self.find_empty() if not empty: empty = self.create_empty() print("created new empty") if self.inputs['Matrix'].is_linked: mats = self.inputs['Matrix'].sv_get() mat = Matrix_generate(mats)[0] else: mat = Matrix() self.label = empty.name empty.matrix_world = mat if 'Objects' in self.outputs: self.outputs['Objects'].sv_set([empty])
def input_mode(self): inputs = self.inputs if (len(inputs) == 0) or (not inputs[0].links): print('has no link!') return # then morph default socket type to whatever we plug into it. from_socket = inputs[0].links[0].from_socket incoming_socket_type = type(from_socket) stype = { VerticesSocket: 'VerticesSocket', MatrixSocket: 'MatrixSocket', StringsSocket: 'StringsSocket' }.get(incoming_socket_type, None) # print(incoming_socket_type, from_socket, stype) if not stype: print('unidentified flying input') return # if the current self.input socket is different to incoming if not (stype == self.inputs[0].bl_idname): self.morph_input_socket_type(stype) # only one nesting level supported, for types other than matrix. # else x gets complicated. x is complex already, this forces # simplicity tvar = None if stype == 'MatrixSocket': prop = SvGetSocketAnyType(self, inputs[0]) tvar = Matrix_generate(prop)[0] # print('---repr-\n', repr(tvar)) else: tvar = SvGetSocketAnyType(self, inputs[0])[0][0] # input can still be empty or [] if not tvar: return if self.eval_str.endswith("with x"): process_input_dofunction(self, tvar) else: process_input_to_bpy(self, tvar, stype)
def process(self): if not self.inputs['Matrices'].is_linked: return vertices = self.inputs['Vertices'].sv_get() matrices = self.inputs['Matrices'].sv_get() matrices = Matrix_generate(matrices) n = len(matrices) result_vertices = (vertices*n)[:n] outV = [] for i, i2 in zip(matrices, result_vertices): outV.append([(i*Vector(v))[:] for v in i2]) edges = self.inputs['Edges'].sv_get(default=[[]]) faces = self.inputs['Faces'].sv_get(default=[[]]) result_edges = (edges * n)[:n] result_faces = (faces * n)[:n] if self.do_join: outV, result_edges, result_faces = mesh_join(outV, result_edges, result_faces) outV, result_edges, result_faces = [outV], [result_edges], [result_faces] self.outputs['Edges'].sv_set(result_edges) self.outputs['Faces'].sv_set(result_faces) self.outputs['Vertices'].sv_set(outV)
def process(self): L, S, R, A = self.outputs M = self.inputs[0] if M.is_linked: matrixes_ = M.sv_get() matrixes = Matrix_generate(matrixes_) if L.is_linked: locs = Matrix_location(matrixes, list=True) L.sv_set(locs) if S.is_linked: locs = Matrix_scale(matrixes, list=True) S.sv_set(locs) if R.is_linked or A.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])) R.sv_set(rots) A.sv_set([angles])
def assign_data(obj, data): ''' assigns data to the object ''' if isinstance(obj, (int, float)): # doesn't work obj = data[0][0] elif isinstance(obj, (Vector, Color)): obj[:] = data[0][0] elif isinstance(obj, (Matrix, Euler, Quaternion)): mats = Matrix_generate(data) mat = mats[0] if isinstance(obj, Euler): eul = mat.to_euler(obj.order) obj[:] = eul elif isinstance(obj, Quaternion): quat = mat.to_quaternion() obj[:] = quat else: #isinstance(obj, Matrix) obj[:] = mat else: # super optimistic guess obj[:] = type(obj)(data[0][0])
def process(self): if not ('vertices' in self.outputs and self.outputs['vertices'].links or 'edges' in self.outputs and self.outputs['edges'].links and 'polygons' in self.outputs and self.outputs['polygons'].links): return if 'vertices' in self.inputs and self.inputs['vertices'].links and \ 'edg_pol' in self.inputs and self.inputs['edg_pol'].links and\ 'cut_matrix' in self.inputs and self.inputs['cut_matrix'].links: verts_ob = Vector_generate( SvGetSocketAnyType(self, self.inputs['vertices'])) edg_pols = SvGetSocketAnyType(self, self.inputs['edg_pol']) cut_mats_ = SvGetSocketAnyType(self, self.inputs['cut_matrix']) cut_mats = Matrix_generate(cut_mats_) verts_out = [] edges_out = [] polys_out = [] for cut_mat in cut_mats: pp = cut_mat.to_translation() pno = Vector((0.0, 0.0, 1.0)) * cut_mat.to_3x3().transposed() for obj in zip(verts_ob, edg_pols): res = bisect(obj[0], obj[1], pp, pno, self.outer, self.inner, self.fill) 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'].links: SvSetSocketAnyType(self, 'vertices', verts_out) if 'edges' in self.outputs and self.outputs['edges'].links: SvSetSocketAnyType(self, 'edges', edges_out) if 'polygons' in self.outputs and self.outputs['polygons'].links: SvSetSocketAnyType(self, 'polygons', polys_out)
def process(self): verts = self.inputs['Vertices'].sv_get() if self.inputs['PolyEdge'].is_linked: poly_edge = self.inputs['PolyEdge'].sv_get() poly_in = True else: poly_in = False poly_edge = repeat_last([[]]) verts_out = [] poly_edge_out = [] item_order = [] poly_output = poly_in and self.outputs['PolyEdge'].is_linked order_output = self.outputs['Item order'].is_linked vert_output = self.outputs['Vertices'].is_linked if not any((vert_output, order_output, poly_output)): return if self.mode == 'XYZ': # should be user settable op_order = [(0, False), (1, False), (2, False)] for v, p in zip(verts, poly_edge): s_v = ((e[0], e[1], e[2], i) for i, e in enumerate(v)) for item_index, rev in op_order: s_v = sorted(s_v, key=itemgetter(item_index), reverse=rev) verts_out.append([v[:3] for v in s_v]) if poly_output: v_index = {item[-1]: j for j, item in enumerate(s_v)} poly_edge_out.append([list(map(lambda n:v_index[n], pe)) for pe in p]) if order_output: item_order.append([i[-1] for i in s_v]) if self.mode == 'DIST': if self.inputs['Base Point'].is_linked: base_points = self.inputs['Base Point'].sv_get() bp_iter = repeat_last(base_points[0]) else: bp = [(0, 0, 0)] bp_iter = repeat_last(bp) for v, p, v_base in zip(verts, poly_edge, bp_iter): s_v = sorted(((v_c, i) for i, v_c in enumerate(v)), key=lambda v: distK(v[0], v_base)) verts_out.append([vert[0] for vert in s_v]) if poly_output: v_index = {item[-1]: j for j, item in enumerate(s_v)} poly_edge_out.append([list(map(lambda n:v_index[n], pe)) for pe in p]) if order_output: item_order.append([i[-1] for i in s_v]) if self.mode == 'AXIS': if self.inputs['Mat'].is_linked: mat = Matrix_generate(self.inputs['Mat'].sv_get()) else: mat = [Matrix. Identity(4)] mat_iter = repeat_last(mat) def f(axis, q): if axis.dot(q.axis) > 0: return q.angle else: return -q.angle for v, p, m in zip(Vector_generate(verts), poly_edge, mat_iter): axis = m @ Vector((0, 0, 1)) axis_norm = m @ Vector((1, 0, 0)) base_point = m @ Vector((0, 0, 0)) intersect_d = [intersect_point_line(v_c, base_point, axis) for v_c in v] rotate_d = [f(axis, (axis_norm + v_l[0]).rotation_difference(v_c)) for v_c, v_l in zip(v, intersect_d)] s_v = ((data[0][1], data[1], i) for i, data in enumerate(zip(intersect_d, rotate_d))) s_v = sorted(s_v, key=itemgetter(0, 1)) verts_out.append([v[i[-1]].to_tuple() for i in s_v]) if poly_output: v_index = {item[-1]: j for j, item in enumerate(s_v)} poly_edge_out.append([list(map(lambda n:v_index[n], pe)) for pe in p]) if order_output: item_order.append([i[-1] for i in s_v]) if self.mode == 'USER': if self.inputs['Index Data'].is_linked: index = self.inputs['Index Data'].sv_get() else: return for v, p, i in zip(verts, poly_edge, index): s_v = sorted([(data[0], data[1], i) for i, data in enumerate(zip(i, v))], key=itemgetter(0)) verts_out.append([obj[1] for obj in s_v]) if poly_output: v_index = {item[-1]: j for j, item in enumerate(s_v)} poly_edge_out.append([[v_index[k] for k in pe] for pe in p]) if order_output: item_order.append([i[-1] for i in s_v]) if self.mode == 'CONNEX': if self.inputs['PolyEdge'].is_linked: edges = self.inputs['PolyEdge'].sv_get() for v, p in zip(verts, edges): pols = [] if len(p[0]) > 2: pols = [p[:]] p = pols_edges([p], True)[0] vect_new, pol_edge_new, index_new = sort_vertices_by_connexions(v, p, self.limit_mode) if len(pols) > 0: new_pols = [] for pol in pols[0]: new_pol = [] for i in pol: new_pol.append(index_new.index(i)) new_pols.append(new_pol) pol_edge_new = [new_pols] verts_out.append(vect_new) poly_edge_out.append(pol_edge_new) item_order.append(index_new) if vert_output: self.outputs['Vertices'].sv_set(verts_out) if poly_output: self.outputs['PolyEdge'].sv_set(poly_edge_out) if order_output: self.outputs['Item order'].sv_set(item_order)
def process(self): # inputs if not (self.inputs['Vertices'].is_linked): return vertices_s = self.inputs['Vertices'].sv_get() edges_s = self.inputs['Edg_Pol'].sv_get(default=[[]]) #faces_s = self.inputs['Polygons'].sv_get(default=[[]]) matrices_s = self.inputs['Matrices'].sv_get(default=[[]]) if is_matrix(matrices_s[0]): matrices_s = [Matrix_generate(matrices_s)] else: matrices_s = [Matrix_generate(matrices) for matrices in matrices_s] #extrude_edges_s = self.inputs['ExtrudeEdges'].sv_get(default=[[]]) result_vertices = [] result_edges = [] result_faces = [] result_ext_vertices = [] result_ext_edges = [] result_ext_faces = [] meshes = match_long_repeat([vertices_s, edges_s, matrices_s]) #, extrude_edges_s]) for vertices, edges, matrices in zip(*meshes): if len(edges[0]) == 2: faces = [] else: faces = edges.copy() edges = [] if not matrices: matrices = [Matrix()] bm = bmesh_from_pydata(vertices, edges, faces) # better to do it in separate node, not integrate by default. #if extrude_edges: # b_edges = [] # for edge in extrude_edges: # b_edge = [e for e in bm.edges if set([v.index for v in e.verts]) == set(edge)] # b_edges.append(b_edge[0]) #else: b_edges = bm.edges new_geom = bmesh.ops.extrude_edge_only( bm, edges=b_edges, use_select_history=False)['geom'] extruded_verts = [ v for v in new_geom if isinstance(v, bmesh.types.BMVert) ] for vertex, matrix in zip( *match_long_repeat([extruded_verts, matrices])): bmesh.ops.transform(bm, verts=[vertex], matrix=matrix, space=Matrix()) extruded_verts = [tuple(v.co) for v in extruded_verts] extruded_edges = [ e for e in new_geom if isinstance(e, bmesh.types.BMEdge) ] extruded_edges = [ tuple(v.index for v in edge.verts) for edge in extruded_edges ] extruded_faces = [ f for f in new_geom if isinstance(f, bmesh.types.BMFace) ] extruded_faces = [[v.index for v in edge.verts] for edge in extruded_faces] new_vertices, new_edges, new_faces = pydata_from_bmesh(bm) bm.free() result_vertices.append(new_vertices) result_edges.append(new_edges) result_faces.append(new_faces) result_ext_vertices.append(extruded_verts) result_ext_edges.append(extruded_edges) result_ext_faces.append(extruded_faces) if self.outputs['Vertices'].is_linked: 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['NewVertices'].is_linked: self.outputs['NewVertices'].sv_set(result_ext_vertices) if self.outputs['NewEdges'].is_linked: self.outputs['NewEdges'].sv_set(result_ext_edges) if self.outputs['NewFaces'].is_linked: self.outputs['NewFaces'].sv_set(result_ext_faces)
def draw_callback_view(n_id, cached_view, options): def Vector_generate2(prop): # try: # return [[Vector(v[:3]) for v in obj] for obj in prop] # except ValueEror: # return [] return [[Vector(v) for v in obj] for obj in prop] # context = bpy.context if options["timings"]: start = time.perf_counter() if options['draw_list'] == 0: sl1 = cached_view[n_id + 'v'] sl2 = cached_view[n_id + 'ep'] sl3 = cached_view[n_id + 'm'] if sl1: data_vector = Vector_generate2(sl1) verlen = len(data_vector) - 1 else: if not sl3: # end early: no matrix and no vertices callback_disable(n_id) return # display matrix repr only. data_vector = [] verlen = 0 options['verlen'] = verlen data_polygons = [] data_edges = [] if sl2 and sl2[0]: if isinstance(sl2[0], int): #callback_disable(n_id) return len_sl2 = len(sl2[0][0]) if len_sl2 == 2: data_edges = sl2 elif len_sl2 > 2: data_polygons = sl2 if sl3: data_matrix = Matrix_generate(sl3) else: data_matrix = [Matrix() for i in range(verlen + 1)] if (data_vector, data_polygons, data_matrix, data_edges) == (0, 0, 0, 0): #callback_disable(n_id) return try: the_display_list = glGenLists(1) glNewList(the_display_list, GL_COMPILE) draw_geometry(n_id, options, data_vector, data_polygons, data_matrix, data_edges) except Exception as err: print("Error in callback!:") traceback.print_exc() options['error'] = True finally: glEndList() options['genlist'] = the_display_list elif options['draw_list'] == 1: the_display_list = options['genlist'] if not 'error' in options: glCallList(the_display_list) glFlush() # restore to system state glLineWidth(1) if options["timings"]: stop = time.perf_counter() print("callback drawn in {:4f}".format(stop - start)) # has drawn once with success. options['draw_list'] = 1
def process(self): # return if no outputs are connected if not any(s.is_linked for s in self.outputs): return inputs = self.inputs outputs = self.outputs identityMatrix = [[tuple(v) for v in Matrix()]] input_verts = inputs['Vertices'].sv_get()[0] input_polys = inputs['PolyEdge'].sv_get()[0] input_matrixT = inputs['Matrix T'].sv_get(default=identityMatrix) input_matrixF = inputs['Matrix F'].sv_get(default=identityMatrix) n = len(input_verts) if inputs['Mask'].is_linked: input_mask = inputs['Mask'].sv_get()[0][:n] input_mask = list(map(lambda x: int(x) % 2, input_mask)) else: # if no mask input, generate a 0,1,0,1 mask input_mask = ([1, 0] * (int((n + 1) / 2)))[:n] matrixF = (Matrix_generate(input_matrixF))[:n] matrixT = (Matrix_generate(input_matrixT))[:n] params = match_long_repeat([input_mask, input_verts, matrixT, matrixF]) # process vertices vertListA, vertListT, vertListF = [[], [], []] for ma, v, mt, mf in zip(*params): if ma == 1: # do some processing using Matrix T here v = (mt * Vector(v))[:] vertListT.append(v) else: # do some processing using Matrix F here v = (mf * Vector(v))[:] vertListF.append(v) vertListA.append(v) # process polyEdges vert_indexT = [i for i, m in enumerate(input_mask) if m] vert_indexF = [i for i, m in enumerate(input_mask) if not m] vt = {j: i for i, j in enumerate(vert_indexT)} vf = {j: i for i, j in enumerate(vert_indexF)} vext = set(vert_indexT) vexf = set(vert_indexF) polyEdgeListA = input_polys polyEdgeListT, polyEdgeListF, polyEdgeListO = [[], [], []] inSetT, inSetF = vext.issuperset, vexf.issuperset addPET, addPEF, addPEO = polyEdgeListT.append, polyEdgeListF.append, polyEdgeListO.append for pe in input_polys: pex = set(pe) if inSetT(pex): addPET([vt[i] for i in pe]) elif inSetF(pex): addPEF([vf[i] for i in pe]) else: addPEO(pe) outputs['Vertices'].sv_set([vertListA]) outputs['PolyEdge'].sv_set([polyEdgeListA]) outputs['PolyEdge O'].sv_set([polyEdgeListO]) outputs['Vertices T'].sv_set([vertListT]) outputs['PolyEdge T'].sv_set([polyEdgeListT]) outputs['Vertices F'].sv_set([vertListF]) outputs['PolyEdge F'].sv_set([polyEdgeListF])
def makeobjects(self, vers, edg_pol, mats): fht = [] if len(edg_pol[0][0]) == 2: pols = [] for edgs in edg_pol: maxi = max(max(a) for a in edgs) fht.append(maxi) elif len(edg_pol[0][0]) > 2: edgs = [] for pols in edg_pol: maxi = max(max(a) for a in pols) fht.append(maxi) vertices = Vector_generate(vers) matrixes = Matrix_generate(mats) objects = {} fhtagn = [] for u, f in enumerate(fht): fhtagn.append(min(len(vertices[u]), fht[u])) #lenmesh = len(vertices) - 1 # name space for particular bakery node # defined only by matrices count (without .001 etc) global sverchok_bakery_cache try: cache = sverchok_bakery_cache[self.name] except: cache = [] names = ['Sv_' + self.name + str(i) for i, t in enumerate(mats)] #print('bakery'+str(names)+str(cache)) bpy.ops.object.select_all(action='DESELECT') for i, obj in enumerate(bpy.context.scene.objects): nam = 'Sv_' + self.name if nam in obj.name: if obj.name not in names: bpy.context.scene.objects[obj.name].select = True bpy.ops.object.delete(use_global=False) for i, m in enumerate(matrixes): # solution to reduce number of vertices respect to edges/pols ######## k = i lenver = len(vertices) - 1 if i > lenver: v = vertices[-1] k = lenver else: v = vertices[k] if (len(v) - 1) < fhtagn[k]: continue elif fhtagn[k] < (len(v) - 1): nonneed = (len(v) - 1) - fhtagn[k] for q in range(nonneed): v.pop((fhtagn[k] + 1)) ######### # end of solution to reduce vertices e = edg_pol[k] if edgs else [] p = edg_pol[k] if pols else [] # to change old, create new separately if names[i] not in cache: objects[str(i)] = self.makemesh(names[i], v, e, p, m) elif bpy.context.scene.objects.find(names[i]) >= 0: objects[str(i)] = self.makemesh_exist(names[i], v, e, p, m) else: objects[str(i)] = self.makemesh(names[i], v, e, p, m) for i, ite in enumerate(objects.values()): me = ite[1] ob = ite[0] calcedg = True if edgs: calcedg = False me.update(calc_edges=calcedg) if ob.name not in cache: bpy.context.scene.objects.link(ob) # save cache sverchok_bakery_cache[self.name] = names