def generate_callback(self, n_id, IV): inputs = self.inputs verts, matrices = [], [] text = '' # gather vertices from input propv = inputs['vertices'].sv_get() verts = dataCorrect(propv) # end early, no point doing anything else. if not verts: return # draw text on locations instead of indices. text_so = inputs['text'].sv_get(default=[]) text = dataCorrect(text_so) if text: fullList(text, len(verts)) for i, t in enumerate(text): fullList(text[i], len(verts[i])) # read non vertex inputs in a loop and assign to data_collected data_collected = [] for socket in ['edges', 'faces', 'matrix']: propm = inputs[socket].sv_get(default=[]) input_stream = dataCorrect(propm) data_collected.append(input_stream) edges, faces, matrices = data_collected bg = self.draw_bg settings = self.get_settings() IV.callback_enable( n_id, verts, edges, faces, matrices, bg, settings, text)
def process(self): if not any(s.is_linked for s in self.outputs): return if self.inputs["Vertices"].is_linked and self.inputs["Poly Egde"].is_linked: verts = self.inputs["Vertices"].sv_get() poly = self.inputs["Poly Egde"].sv_get() verts = dataCorrect(verts) poly = dataCorrect(poly) self.inputs["Mask"].sv_get(default=[[1, 0]]) has_true_out = True has_false_out = False verts_out = [] poly_edge_out = [] for ve, pe, ma in zip(verts, poly, repeat_last(mask)): current_mask = islice(cycle(ma), len(ve)) vert_index = [i for i, m in enumerate(current_mask) if m] if len(vert_index) < len(ve): index_set = set(vert_index) if has_true_out: vert_dict = {j: i for i, j in enumerate(vert_index)} new_vert = [ve[i] for i in vert_index] is_ss = index_set.issuperset new_pe = [[vert_dict[n] for n in fe] for fe in pe if is_ss(fe)] verts_out.append(new_vert) poly_edge_out.append(new_pe) else: # no reprocessing needed verts_out.append(ve) poly_edge_out.append(pe) self.outputs["Vertices"].sv_set(verts_out) self.outputs["Poly Egde"].sv_set(poly_edge_out)
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 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): 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): 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 (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) global cache_viewer_baker vertex_ref = n_id + 'v' poledg_ref = n_id + 'ep' matrix_ref = n_id + 'm' cache_viewer_baker[vertex_ref] = [] cache_viewer_baker[poledg_ref] = [] cache_viewer_baker[matrix_ref] = [] callback_disable(n_id) # every time you hit a dot, you pay a price, so alias and benefit inputs = self.inputs # this should catch accidental connections which otherwise will cause # an unrecoverable crash. It might even be an idea to have step in between # new connections and processing, it could auto rewire s->s v->v m->m. def check_origin(to_socket, socket_type): sock_string = sock_dict.get(socket_type) return inputs[to_socket].links[0].from_socket.bl_idname == sock_string vertex_links = inputs['vertices'].is_linked and check_origin('vertices', 'v') matrix_links = inputs['matrix'].is_linked and check_origin('matrix', 'm') edgepol_links = inputs['edg_pol'].is_linked and check_origin('edg_pol', 's') if (vertex_links or matrix_links): if vertex_links: propv = inputs['vertices'].sv_get(deepcopy=False, default=[]) if propv: verts = dataCorrect(propv) for v in verts: if any(l != 3 for l in map(len, v)): raise ValueError cache_viewer_baker[vertex_ref] = verts if edgepol_links: prope = inputs['edg_pol'].sv_get(deepcopy=False, default=[]) if prope: cache_viewer_baker[poledg_ref] = dataCorrect(prope) if matrix_links: propm = inputs['matrix'].sv_get(deepcopy=False, default=[]) if propm: cache_viewer_baker[matrix_ref] = dataCorrect(propm) if cache_viewer_baker[vertex_ref] or cache_viewer_baker[matrix_ref]: config_options = self.get_options() callback_enable(n_id, cache_viewer_baker, config_options)
def process(self): if not self.outputs["data"].is_linked: return data_ = self.inputs["data"].sv_get() data = dataCorrect(data_, nominal_dept=self.level) out_ = [] for obj in data: out_.append(svQsort(obj)) out = dataCorrect(out_) self.outputs["data"].sv_set(out)
def execute(self, context): global cache_viewer_baker nid = node_id(bpy.data.node_groups[self.idtree].nodes[self.idname]) if cache_viewer_baker[nid + "m"] and not cache_viewer_baker[nid + "v"]: return {"CANCELLED"} vers = dataCorrect(cache_viewer_baker[nid + "v"]) edg_pol = dataCorrect(cache_viewer_baker[nid + "ep"]) if cache_viewer_baker[nid + "m"]: matrixes = dataCorrect(cache_viewer_baker[nid + "m"]) else: matrixes = [] for i in range((len(vers))): matrixes.append(Matrix()) self.makeobjects(vers, edg_pol, matrixes) return {"FINISHED"}
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): verts_socket, polys_socket = self.inputs vol_socket = self.outputs[0] if vol_socket.is_linked and verts_socket.is_linked: # and polys_socket.is_linked ? vertices = Vector_generate(dataCorrect(verts_socket.sv_get())) faces = dataCorrect(polys_socket.sv_get()) out = [] for verts_obj, faces_obj in zip(vertices, faces): bm = bmesh_from_pydata(verts_obj, [], faces_obj, normal_update=True) out.append(bm.calc_volume()) bm.free() vol_socket.sv_set(out)
def process(self): if not self.outputs[0].is_linked: return X_ = self.inputs['pols'].sv_get() X = dataCorrect(X_) result = pols_edges(X, self.unique_edges) self.outputs['edgs'].sv_set(result)
def process(self): """ colorsys.rgb_to_yiq(r, g, b) colorsys.yiq_to_rgb(y, i, q) colorsys.rgb_to_hls(r, g, b) colorsys.hls_to_rgb(h, l, s) colorsys.rgb_to_hsv(r, g, b) colorsys.hsv_to_rgb(h, s, v) """ color_input = self.inputs['Colors'] if color_input.is_linked: abc = self.inputs['Colors'].sv_get() data = dataCorrect(abc) else: data = [[self.unit_color[:]]] A, B, C, D = [], [], [], [] if self.use_alpha: for obj in data: a_, b_, c_, d_ = (list(x) for x in zip(*obj)) A.append(a_) B.append(b_) C.append(c_) D.append(d_) for i, socket in enumerate(self.outputs): self.outputs[socket.name].sv_set([A, B, C, D][i]) else: for obj in data: a_, b_, c_ = (list(x) for x in zip(*obj)) A.append(a_) B.append(b_) C.append(c_) for i, socket in enumerate(self.outputs[:3]): self.outputs[socket.name].sv_set([A, B, C][i])
def process(self): if not any(s.is_linked for s in self.outputs): return if self.inputs['Vertices'].is_linked: verts = self.inputs['Vertices'].sv_get() 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) self.outputs['Vertices'].sv_set(verts_out)
def process(self): if not any(s.is_linked for s in self.outputs): return if self.inputs['Vertices'].is_linked: verts = self.inputs['Vertices'].sv_get() verts = dataCorrect(verts) t_ins_x = self.inputs['IntervalX'].sv_get() t_ins_y = self.inputs['IntervalY'].sv_get() if self.regime == 'P' and self.direction == 'U': self.direction = 'UV' if self.defgrid: t_ins_x = [[i/10 for i in range(11)]] t_ins_y = [[i/10 for i in range(11)]] if self.regime == 'G': vertsX = self.interpol(verts, t_ins_x) if self.direction == 'UV': verts_T = np.swapaxes(np.array(vertsX),0,1).tolist() verts_out = self.interpol(verts_T, t_ins_y) else: verts_out = vertsX else: verts_out_ = [] for x,y in zip(t_ins_x[0],t_ins_y[0]): vertsX = self.interpol(verts, [[x]]) verts_T = np.swapaxes(np.array(vertsX),0,1).tolist() vertsY = self.interpol(verts_T, [[y]]) verts_out_.extend(vertsY) verts_out = [[i[0] for i in verts_out_]] self.outputs['Vertices'].sv_set(verts_out)
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 = self.flip(outCorr, levels) SvSetSocketAnyType(self, 'data', out)
def get_corrected_data(self, socket_name, socket_type): inputs = self.inputs socket = inputs[socket_name].links[0].from_socket if isinstance(socket, socket_type): return dataCorrect(inputs[socket_name].sv_get()) else: return []
def get_input_or_default(self, name, this_val, fparams): """ fill up the fparams list with found or default values """ socket = self.inputs[name] # this deals with incoming links only. if socket.links: if isinstance(this_val, list): try: this_val = socket.sv_get() this_val = dataCorrect(this_val) except: pass elif isinstance(this_val, (int, float)): try: k = str(socket.sv_get()) kfree = k[2:-2] this_val = ast.literal_eval(kfree) # this_val = socket.sv_get()[0][0] except: pass # this catches movement on UI sliders. elif isinstance(this_val, (int, float)): # extra pussyfooting for the load sequence. t = socket.sv_get() if t and t[0] and t[0][0]: this_val = t[0][0] # either found input, or uses default. fparams.append(this_val)
def get_corrected_data(self, socket_name, socket_type): inputs = self.inputs socket = inputs[socket_name].links[0].from_socket if isinstance(socket, socket_type): socket_in = SvGetSocketAnyType(self, inputs[socket_name]) return dataCorrect(socket_in) else: return []
def meta_get(self, s_name, fallback, level): ''' private function for the get_input function, accepts level 0..2 - if socket has no links, then return fallback value - s_name can be an index instead of socket name ''' inputs = self.inputs if inputs[s_name].is_linked: socket_in = inputs[s_name].sv_get() if level == 1: data = dataCorrect(socket_in)[0] elif level == 2: data = dataCorrect(socket_in)[0][0] else: data = dataCorrect(socket_in) return data else: return fallback
def process(self): if not self.outputs['data'].is_linked: return data_ = self.inputs['data'].sv_get() data = dataCorrect(data_, nominal_dept=self.level).copy() out_ = [] if not self.inputs['keys'].is_linked: for obj in data: out_.append(svQsort(obj)) else: keys_ = self.inputs['keys'].sv_get() keys = dataCorrect(keys_, nominal_dept=1) for d,k in zip(data,keys): d.sort(key = lambda x: k.pop(0)) out_.append(d) out = dataCorrect(out_) self.outputs['data'].sv_set(out)
def process(self): if 'edgs' in self.outputs and len(self.outputs['edgs'].links) > 0: if 'pols' in self.inputs and len(self.inputs['pols'].links) > 0: X_ = SvGetSocketAnyType(self, self.inputs['pols']) X = dataCorrect(X_) #print('p2e-X',str(X)) result = self.pols_edges(X) #result = self.polstoedgs(X) SvSetSocketAnyType(self, 'edgs', result)
def process(self): if self.outputs['Volume'].is_linked and self.inputs['Vers'].is_linked: vertices = Vector_generate(dataCorrect(SvGetSocketAnyType(self, self.inputs['Vers']))) faces = dataCorrect(SvGetSocketAnyType(self, self.inputs['Pols'])) out = [] for verts_obj, faces_obj in zip(vertices, faces): # this is for one object bme = bmesh_from_pydata(verts_obj, [], faces_obj) geom_in = bme.verts[:]+bme.edges[:]+bme.faces[:] bmesh.ops.recalc_face_normals(bme, faces=bme.faces[:]) # calculation itself out.append(bme.calc_volume()) bme.clear() bme.free() if self.outputs['Volume'].is_linked: SvSetSocketAnyType(self, 'Volume', out)
def process(self): if not (self.id_data.sv_show and self.activate): callback_disable(node_id(self)) return n_id = node_id(self) global cache_viewer_baker vertex_ref = n_id + 'v' poledg_ref = n_id + 'ep' matrix_ref = n_id + 'm' cache_viewer_baker[vertex_ref] = [] cache_viewer_baker[poledg_ref] = [] cache_viewer_baker[matrix_ref] = [] callback_disable(n_id) # every time you hit a dot, you pay a price, so alias and benefit inputs = self.inputs vertex_links = inputs['vertices'].is_linked matrix_links = inputs['matrix'].is_linked edgepol_links = inputs['edg_pol'].is_linked if vertex_links or matrix_links: if vertex_links: propv = inputs['vertices'].sv_get(deepcopy=False, default=[]) if propv: cache_viewer_baker[vertex_ref] = dataCorrect(propv) if edgepol_links: prope = inputs['edg_pol'].sv_get(deepcopy=False, default=[]) if prope: cache_viewer_baker[poledg_ref] = dataCorrect(prope) if matrix_links: propm = inputs['matrix'].sv_get(deepcopy=False, default=[]) if propm: cache_viewer_baker[matrix_ref] = dataCorrect(propm) if cache_viewer_baker[vertex_ref] or cache_viewer_baker[matrix_ref]: config_options = self.get_options() callback_enable(n_id, cache_viewer_baker, config_options)
def update(self): # multisocket - from util(formula node) multi_socket(self, min=2) if 'x0' in self.inputs and len(self.inputs['x0'].links) > 0: # adaptive socket - from util(mask list node) inputsocketname = self.inputs[ 0].name # is you need x0 to define socket type - set 0 to 1 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: # get any type socket from input: X = SvGetSocketAnyType(self, self.inputs['data']) slots = [] for socket in self.inputs: if socket.links: slots.append(SvGetSocketAnyType(self, socket)) # determine if you have enough inputs for make output # if not return # examples: all but last (last is never connected) # len(slots) == len(self.inputs)-1 # if more than 2 etc. if len(slots) < 2: return # Process data X_ = dataCorrect(X) result = [] for socket in slots: result.extend(self.f(X_, dataCorrect(socket))) # how to assign correct property to adaptive output: # in nearest future with socket's data' dictionary we will send # only node_name+layout_name+socket_name in str() format # and will make separate definition to easyly assign and # get and recognise data from dictionary SvSetSocketAnyType(self, 'data', result)
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): verts_socket, polys_socket = self.inputs vol_socket = self.outputs[0] if vol_socket.is_linked and verts_socket.is_linked: # and polys_socket.is_linked ? vertices = Vector_generate(dataCorrect(verts_socket.sv_get())) faces = dataCorrect(polys_socket.sv_get()) out = [] for verts_obj, faces_obj in zip(vertices, faces): # this is for one object bm = bmesh_from_pydata(verts_obj, [], faces_obj) # geom_in = bm.verts[:] + bm.edges[:] + bm.faces[:] bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:]) out.append(bm.calc_volume()) bm.clear() bm.free() vol_socket.sv_set(out)
def process(self): if self.inputs['X'].is_linked: vecs = SvGetSocketAnyType(self, self.inputs['X']) else: vecs = [[0.0]] # outputs if not self.outputs['Result'].is_linked: return list_mult = [] if self.inputs['n[0]'].is_linked: i = 0 for socket in self.inputs[1:]: if socket.is_linked: list_mult.append(SvGetSocketAnyType(self, socket)) #print(list_mult) code_formula = parser.expr(self.formula).compile() # finding nasty levels, make equal nastyness (canonical 0,1,2,3) levels = [levelsOflist(vecs)] for n in list_mult: levels.append(levelsOflist(n)) maxlevel = max(max(levels), 3) diflevel = maxlevel - levels[0] if diflevel: vecs_ = dataSpoil([vecs], diflevel-1) vecs = dataCorrect(vecs_, nominal_dept=2) for i, lev in enumerate(levels): if i == 0: continue diflevel = maxlevel-lev if diflevel: list_temp = dataSpoil([list_mult[i-1]], diflevel-1) list_mult[i-1] = dataCorrect(list_temp, nominal_dept=2) #print(list_mult) r = self.inte(vecs, code_formula, list_mult, 3) result = dataCorrect(r, nominal_dept=min((levels[0]-1), 2)) SvSetSocketAnyType(self, 'Result', result)
def process(self): if not self.inputs[1] and not self.inputs[1].is_linked: return matrices = dataCorrect(self.inputs[0].sv_get()) objects = self.inputs[1].sv_get() matrices, objects = match_long_repeat([matrices, objects]) for obj, mat in zip(objects, matrices): setattr(obj, 'matrix_world', mat) if self.outputs[0].is_linked: self.outputs[0].sv_set(objects)
def process(self): if not any((s.is_linked for s in self.outputs)): return if self.inputs['Vertices'].is_linked and self.inputs['Poly Egde'].is_linked: verts = SvGetSocketAnyType(self, self.inputs['Vertices']) poly = SvGetSocketAnyType(self, self.inputs['Poly Egde']) verts = dataCorrect(verts) poly = dataCorrect(poly) if self.inputs['Mask'].is_linked: mask = SvGetSocketAnyType(self, self.inputs['Mask']) else: mask = [[1, 0]] has_true_out = True has_false_out = False verts_out = [] poly_edge_out = [] for ve, pe, ma in zip(verts, poly, repeat_last(mask)): current_mask = islice(cycle(ma), len(ve)) vert_index = [i for i, m in enumerate(current_mask) if m] if len(vert_index) < len(ve): index_set = set(vert_index) if has_true_out: vert_dict = {j: i for i, j in enumerate(vert_index)} new_vert = [ve[i] for i in vert_index] is_ss = index_set.issuperset new_pe = [[vert_dict[n] for n in fe] for fe in pe if is_ss(fe)] verts_out.append(new_vert) poly_edge_out.append(new_pe) else: # no reprocessing needed verts_out.append(ve) poly_edge_out.append(pe) if 'Vertices' in self.outputs and self.outputs['Vertices'].is_linked: SvSetSocketAnyType(self, 'Vertices', verts_out) if 'Poly Egde' in self.outputs and self.outputs['Poly Egde'].is_linked: if poly_edge_out: SvSetSocketAnyType(self, 'Poly Egde', poly_edge_out)
def update(self): # multisocket - from util(formula node) multi_socket(self, min=2) if 'x0' in self.inputs and len(self.inputs['x0'].links) > 0: # adaptive socket - from util(mask list node) inputsocketname = self.inputs[0].name # is you need x0 to define socket type - set 0 to 1 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: # get any type socket from input: X = SvGetSocketAnyType(self, self.inputs['data']) slots = [] for socket in self.inputs: if socket.links: slots.append(SvGetSocketAnyType(self, socket)) # determine if you have enough inputs for make output # if not return # examples: all but last (last is never connected) # len(slots) == len(self.inputs)-1 # if more than 2 etc. if len(slots) < 2: return # Process data X_ = dataCorrect(X) result = [] for socket in slots: result.extend(self.f(X_, dataCorrect(socket))) # how to assign correct property to adaptive output: # in nearest future with socket's data' dictionary we will send # only node_name+layout_name+socket_name in str() format # and will make separate definition to easyly assign and # get and recognise data from dictionary SvSetSocketAnyType(self, 'data', result)
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): 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 not (self.inputs['vertices'].is_linked and self.inputs['edges'].is_linked): return verts = dataCorrect(self.inputs['vertices'].sv_get()) edges = dataCorrect(self.inputs['edges'].sv_get()) 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]) self.outputs['vertices'].sv_set(verts_out) self.outputs['edges'].sv_set(edges_out) self.outputs['polygons'].sv_set(polys_out)