def update(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 update(self): for name in ['vertices1', 'vertices2', 'matrix1', 'matrix2']: if name not in self.inputs: return if self.inputs['vertices1'].links and self.inputs['vertices2'].links: prop1_ = SvGetSocketAnyType(self, self.inputs['vertices1']) prop1 = Vector_generate(prop1_) prop2_ = SvGetSocketAnyType(self, self.inputs['vertices2']) prop2 = Vector_generate(prop2_) elif self.inputs['matrix1'].links and self.inputs['matrix2'].links: 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'].links: #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 update(self): if not 'Edges' in self.outputs: return if not all((s.links for s in self.inputs)): return if not any((s.links 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'].links: SvSetSocketAnyType(self, 'Vertices', verts_out) if 'Edges' in self.outputs and self.outputs['Edges'].links: SvSetSocketAnyType(self, 'Edges', edges_out)
def update(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 update(self): # inputs 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 if 'Matrix' in self.outputs and self.outputs['Matrix'].links: max_l = max(len(loc[0]), len(scale[0]), len(rot[0]), len(angle[0]), len(rotA[0])) orig = [] for l in range(max_l): M = mathutils.Matrix() orig.append(M) if len(orig) == 0: return matrixes_ = matrixdef(orig, loc, scale, rot, angle, rotA) matrixes = Matrix_listing(matrixes_) SvSetSocketAnyType(self, 'Matrix', matrixes)
def update(self): if not self.noise_dict: self.noise_dict = { t[0]: t[1] for t in inspect.getmembers(noise.types) if isinstance(t[1], int) } if self.outputs and not self.outputs[0].links: return if 'Vertices' in self.inputs and self.inputs['Vertices'].links: verts = Vector_generate( SvGetSocketAnyType(self, self.inputs['Vertices'])) out = [] n_t = self.noise_dict[self.noise_type] n_f = self.noise_f[self.out_mode] for obj in verts: out.append([n_f(v, n_t) for v in obj]) if 'Noise V' in self.outputs and self.outputs['Noise V'].links: SvSetSocketAnyType(self, 'Noise V', Vector_degenerate(out)) if 'Noise S' in self.outputs and self.outputs['Noise S'].links: SvSetSocketAnyType(self, 'Noise S', out) return SvSetSocketAnyType(self, self.outputs[0].name, [[]])
def update(self): # inputs if 'Vectors' in self.outputs and len( self.outputs['Vectors'].links) > 0: if self.inputs['Vectors'].links and \ type(self.inputs['Vectors'].links[0].from_socket) == VerticesSocket \ and self.inputs['Matrixes'] and \ type(self.inputs['Matrixes'].links[0].from_socket) == MatrixSocket: vecs_ = SvGetSocketAnyType(self, self.inputs['Vectors']) vecs = Vector_generate(vecs_) #print (vecs) mats_ = dataCorrect( SvGetSocketAnyType(self, self.inputs['Matrixes'])) mats = Matrix_generate(mats_) else: vecs = [[]] mats = [Matrix()] # outputs vectors_ = self.vecscorrect(vecs, mats) vectors = Vector_degenerate(vectors_) SvSetSocketAnyType(self, 'Vectors', vectors)
def sv_main(vec=[], pol=[], iter=3): in_sockets = [['v', 'vec', vec], ['s', 'pol', pol], ['s', 'iter', iter]] if not vec: vec = [[[0, 1, 1], [0, 2, 2], [3, 3, 0]]] if not pol: pol = [[[0, 1, 2]]] vec_gen = Vector_generate(vec) def fractalize(vec_gen, pol, iter): out = [] if iter: print(vec_gen, iter) vers_new = [] for obj in vec_gen: for v1 in obj: up = [v1 / 2 + v2 / 2 for v2 in vec_gen[0]] vers_new.append(up) #print(levelsOflist(vec_gen)) #pols_new =[[vec[p] for p in objpol] for objpol in pol] out = fractalize(vers_new, pol, iter - 1) else: out = dataCorrect(vec_gen, 1) #print(out) return out out_ = fractalize(vec_gen, pol, iter) out = Vector_degenerate(out_) #print(out) out_sockets = [['v', 'vec', out]] return in_sockets, out_sockets
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(SvGetSocketAnyType(node, inputs[name])) 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 update(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 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]: 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 update(self): if not 'polygons' in self.outputs: return if not any((s.links for s in self.outputs)): return if 'vertices' in self.inputs and self.inputs['vertices'].links and \ 'polygons' in self.inputs and self.inputs['polygons'].links: verts = Vector_generate( SvGetSocketAnyType(self, self.inputs['vertices'])) polys = SvGetSocketAnyType(self, self.inputs['polygons']) if 'thickness' in self.inputs: thickness = self.inputs['thickness'].sv_get() else: thickness = [[self.thickness]] #print (verts,polys) verts_out = [] edges_out = [] polys_out = [] newpo_out = [] fullList(thickness, len(verts)) for v, p, t in zip(verts, polys, thickness): verlen = set(range(len(v))) res = soldify(v, p, t, verlen) if not res: return verts_out.append(res[0]) edges_out.append(res[1]) polys_out.append(res[2]) newpo_out.append(res[3]) 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) if 'newpols' in self.outputs and self.outputs['newpols'].links: SvSetSocketAnyType(self, 'newpols', newpo_out)
def update(self): if self.outputs['Volume'].links and self.inputs['Vers'].links: 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'].links: SvSetSocketAnyType(self, 'Volume', out)
def update(self): if not any([s.links for s in self.outputs]): return if 'Vertices' in self.inputs and self.inputs['Vertices'].links and \ 'PolyEdge' in self.inputs and self.inputs['PolyEdge'].links: verts = Vector_generate(SvGetSocketAnyType(self, self.inputs['Vertices'])) polys = SvGetSocketAnyType(self, self.inputs['PolyEdge']) if 'Distance' in self.inputs: distance = self.inputs['Distance'].sv_get()[0] else: distance = [self.distance] if 'Doubles' in self.outputs: has_double_out = bool('Doubles' in self.outputs) verts_out = [] edges_out = [] polys_out = [] d_out = [] for v, p, d in zip(verts, polys, repeat_last(distance)): res = remove_doubles(v, p, d, has_double_out) if not res: return verts_out.append(res[0]) edges_out.append(res[1]) polys_out.append(res[2]) d_out.append(res[3]) 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) if 'Doubles' in self.outputs and self.outputs['Doubles'].links: SvSetSocketAnyType(self, 'Doubles', d_out)
def update(self): if 'Vertices' in self.inputs and self.inputs['Vertices'].links: verts = Vector_generate( SvGetSocketAnyType(self, self.inputs['Vertices'])) verts_out = [] polys_out = [] for v_obj in verts: res = make_hull(v_obj) if not res: return verts_out.append(res[0]) polys_out.append(res[1]) if 'Vertices' in self.outputs and self.outputs['Vertices'].links: SvSetSocketAnyType(self, 'Vertices', verts_out) if 'Polygons' in self.outputs and self.outputs['Polygons'].links: SvSetSocketAnyType(self, 'Polygons', polys_out)
def update(self): if not ('vertices' in self.outputs and self.outputs['vertices'].links or 'edges' in self.outputs and self.outputs['edges'].links or 'polygons' in self.outputs and self.outputs['polygons'].links): return if 'vertices' in self.inputs and self.inputs['vertices'].links and \ 'polygons' in self.inputs and self.inputs['polygons'].links: verts = Vector_generate( SvGetSocketAnyType(self, self.inputs['vertices'])) polys = SvGetSocketAnyType(self, self.inputs['polygons']) if 'thickness' in self.inputs: thickness = self.inputs['thickness'].sv_get()[0] else: thickness = [self.thickness] verts_out = [] edges_out = [] polys_out = [] for v, p, t in zip(verts, polys, repeat_last(thickness)): res = wireframe(v, p, t, self.offset, self.replace, self.boundary, self.even_offset, self.relative_offset) 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 update(self): if self.outputs['Vers'].links and self.inputs['Vers'].links: vertices = Vector_generate( SvGetSocketAnyType(self, self.inputs['Vers'])) faces = SvGetSocketAnyType(self, self.inputs['Pols']) offset = self.inputs['Offset'].sv_get()[0] nsides = self.inputs['N sides'].sv_get()[0][0] radius = self.inputs['Radius'].sv_get()[0] #print(radius,nsides,offset) outv = [] oute = [] outo = [] outn = [] for verts_obj, faces_obj in zip(vertices, faces): # this is for one object fullList(offset, len(faces_obj)) fullList(radius, len(faces_obj)) verlen = set(range(len(verts_obj))) 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[:]) list_0 = [f.index for f in bme.faces] # calculation itself result = \ self.Offset_pols(bme, list_0, offset, radius, nsides, verlen) outv.append(result[0]) oute.append(result[1]) outo.append(result[2]) outn.append(result[3]) if self.outputs['Vers'].links: SvSetSocketAnyType(self, 'Vers', outv) if self.outputs['Edgs'].links: SvSetSocketAnyType(self, 'Edgs', oute) if self.outputs['OutPols'].links: SvSetSocketAnyType(self, 'OutPols', outo) if self.outputs['InPols'].links: SvSetSocketAnyType(self, 'InPols', outn)
def process(self): 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'].links: SvSetSocketAnyType(self, 'Vertices', verts_out) SvSetSocketAnyType(self, 'Polygons', polys_out)
def update(self): # inputs if 'Vectors' in self.outputs and self.outputs['Vectors'].links: if not ('Vectors' in self.inputs and self.inputs['Vectors'].links): return if not ('Matrixes' in self.inputs and self.inputs['Matrixes'].links): return if type(self.inputs['Vectors'].links[0].from_socket) == VerticesSocket and \ type(self.inputs['Matrixes'].links[0].from_socket) == MatrixSocket: vecs_ = SvGetSocketAnyType(self, self.inputs['Vectors']) vecs = Vector_generate(vecs_) mats_ = SvGetSocketAnyType(self, self.inputs['Matrixes']) mats = Matrix_generate(mats_) else: vecs = [[]] mats = [Matrix()] # outputs vectors_ = self.vecscorrect(vecs, mats) vectors = Vector_degenerate(vectors_) SvSetSocketAnyType(self, 'Vectors', vectors)
def makeobjects(self, vers, edg_pol, mats): # 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) 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)) # delete previous objects удаляет предыдущие объекты, если есть, если надо. 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
def process(self): SSSAT = SvSetSocketAnyType bcsrc = bpy.context.scene.ray_cast outputs = self.outputs out = [] OutLoc = [] OutNorm = [] INDSucc = [] OutMatrix = [] ObjectID = [] st = Vector_generate(SvGetSocketAnyType(self, self.inputs['start'])) en = Vector_generate(SvGetSocketAnyType(self, self.inputs['end'])) start = [Vector(x) for x in st[0]] end = [Vector(x) for x in en[0]] if self.Iteration == 'match_short': temp = match_short([start, end]) start, end = temp[0], temp[1] if self.Iteration == 'match_long_repeat': temp = match_long_repeat([start, end]) start, end = temp[0], temp[1] if self.Modes == 'Object' and (self.formula in bpy.data.objects): if 'data.object' in outputs: outputs.remove(outputs['data.object']) if 'hited object matrix' in outputs: outputs.remove(outputs['hited object matrix']) obj = bpy.data.objects[self.formula] i = 0 while i < len(end): out.append(obj.ray_cast(start[i], end[i])) i = i + 1 for i in out: OutNorm.append(i[1][:]) INDSucc.append(i[2]) OutLoc.append(i[0][:]) if self.Modes == 'World': if 'data.object' not in outputs: outputs.new("VerticesSocket", "data.object") if 'hited object matrix' not in outputs: outputs.new("MatrixSocket", "hited object matrix") for i, last in enumerate(end): src = bcsrc(start[i], last) OutLoc.append(src[3][:]) OutNorm.append(src[4][:]) INDSucc.append(src[0]) OutMatrix.append(src[2][:]) OutMatrix = [[a[:], b[:], c[:], d[:]] for a, b, c, d in OutMatrix] ObjectID.append(src[1]) if outputs['HitP'].links: SSSAT(self, 'HitP', [OutLoc]) if outputs['HitNorm'].links: SSSAT(self, 'HitNorm', [OutNorm]) if outputs['INDEX/Succes'].links: SSSAT(self, 'INDEX/Succes', [INDSucc]) if 'hited object matrix' in outputs: if outputs['hited object matrix'].links: SSSAT(self, 'hited object matrix', OutMatrix) if 'data.object' in outputs: if outputs['data.object'].links: SSSAT(self, 'data.object', [ObjectID])
def draw_callback_px(n_id, draw_verts, draw_edges, draw_faces, draw_matrix, draw_bg, settings, text): context = bpy.context # ensure data or empty lists. data_vector = Vector_generate(draw_verts) if draw_verts else [] data_edges = draw_edges data_faces = draw_faces data_matrix = Matrix_generate(draw_matrix) if draw_matrix else [] data_text = text if (data_vector, data_matrix) == (0, 0): # callback_disable(n_id) # not sure that it is safe to disable the callback in callback # just return instead. return region = context.region region3d = context.space_data.region_3d vert_idx_color = settings['numid_verts_col'] edge_idx_color = settings['numid_edges_col'] face_idx_color = settings['numid_faces_col'] vert_bg_color = settings['bg_verts_col'] edge_bg_color = settings['bg_edges_col'] face_bg_color = settings['bg_faces_col'] display_vert_index = settings['display_vert_index'] display_edge_index = settings['display_edge_index'] display_face_index = settings['display_face_index'] font_id = 0 text_height = 13 blf.size(font_id, text_height, 72) # should check prefs.dpi region_mid_width = region.width / 2.0 region_mid_height = region.height / 2.0 # vars for projection perspective_matrix = region3d.perspective_matrix.copy() def draw_index(rgb, rgb2, index, vec, text=''): vec_4d = perspective_matrix * vec.to_4d() if vec_4d.w <= 0.0: return x = region_mid_width + region_mid_width * (vec_4d.x / vec_4d.w) y = region_mid_height + region_mid_height * (vec_4d.y / vec_4d.w) if text: index = str(text[0]) else: index = str(index) if draw_bg: polyline = get_points(index) ''' draw polygon ''' bgl.glColor4f(*rgb2) bgl.glBegin(bgl.GL_POLYGON) for pointx, pointy in polyline: bgl.glVertex2f(pointx+x, pointy+y) bgl.glEnd() ''' draw text ''' txt_width, txt_height = blf.dimensions(0, index) bgl.glColor4f(*rgb) blf.position(0, x - (txt_width / 2), y - (txt_height / 2), 0) blf.draw(0, index) ######## # points def calc_median(vlist): a = Vector((0, 0, 0)) for v in vlist: a += v return a / len(vlist) for obj_index, verts in enumerate(data_vector): final_verts = verts if data_text: text_obj = data_text[obj_index] else: text_obj = '' # quicklt apply matrix if necessary if draw_matrix: matrix = data_matrix[obj_index] final_verts = [matrix * v for v in verts] if display_vert_index: for idx, v in enumerate(final_verts): if text_obj: draw_index(vert_idx_color, vert_bg_color, idx, v, text_obj[idx]) else: draw_index(vert_idx_color, vert_bg_color, idx, v) if data_edges and display_edge_index: for edge_index, (idx1, idx2) in enumerate(data_edges[obj_index]): v1 = Vector(final_verts[idx1]) v2 = Vector(final_verts[idx2]) loc = v1 + ((v2 - v1) / 2) if text_obj: draw_index(edge_idx_color, edge_bg_color, edge_index, loc, text_obj[edge_index]) else: draw_index(edge_idx_color, edge_bg_color, edge_index, loc) if data_faces and display_face_index: for face_index, f in enumerate(data_faces[obj_index]): verts = [Vector(final_verts[idx]) for idx in f] median = calc_median(verts) if text_obj: draw_index(face_idx_color, face_bg_color, face_index, median, text_obj[face_index]) else: draw_index(face_idx_color, face_bg_color, face_index, median)
def draw_callback_view(handle, sl1, sl2, sl3, vs, colo, tran, shade): context = bpy.context from bgl import glEnable, glDisable, glColor3f, glVertex3f, glPointSize, \ glLineWidth, glBegin, glEnd, glLineStipple, GL_POINTS, \ GL_LINE_STRIP, GL_LINES, GL_LINE, GL_LINE_STIPPLE, GL_POLYGON, \ GL_POLYGON_STIPPLE, GL_POLYGON_SMOOTH, glPolygonStipple, \ GL_TRIANGLES, GL_QUADS, glColor4f # define globals, separate edgs from pols if tran: polyholy = GL_POLYGON_STIPPLE edgeholy = GL_LINE_STIPPLE edgeline = GL_LINE_STRIP else: polyholy = GL_POLYGON edgeholy = GL_LINE edgeline = GL_LINES if sl1: data_vector = Vector_generate(sl1) verlen = len(data_vector) - 1 verlen_every = [len(d) - 1 for d in data_vector] else: data_vector = [] verlen = 0 if sl2: if sl2[0]: if len(sl2[0][0]) == 2: data_edges = sl2 data_polygons = [] elif len(sl2[0][0]) > 2: data_polygons = sl2 data_edges = [] else: data_polygons = [] data_edges = [] else: data_edges, data_polygons = [], [] if sl3: data_matrix = Matrix_generate(sl3) else: data_matrix = [Matrix() for i in range(verlen + 1)] coloa = colo[0] colob = colo[1] coloc = colo[2] if (data_vector, data_polygons, data_matrix, data_edges) == (0, 0, 0, 0): callback_disable(handle) #print ('вход', sl1, sl2, sl3) #print ('преобраз', data_vector) # draw_matrix vars zero = Vector((0.0, 0.0, 0.0)) x_p = Vector((0.5, 0.0, 0.0)) x_n = Vector((-0.5, 0.0, 0.0)) y_p = Vector((0.0, 0.5, 0.0)) y_n = Vector((0.0, -0.5, 0.0)) z_p = Vector((0.0, 0.0, 0.5)) z_n = Vector((0.0, 0.0, -0.5)) bb = [Vector() for i in range(24)] def draw_matrix(mat): zero_tx = mat * zero glLineWidth(2.0) # x glColor3f(1.0, 0.2, 0.2) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * x_p)) glEnd() glColor3f(0.6, 0.0, 0.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * x_n)) glEnd() # y glColor3f(0.2, 1.0, 0.2) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * y_p)) glEnd() glColor3f(0.0, 0.6, 0.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * y_n)) glEnd() # z glColor3f(0.2, 0.2, 1.0) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * z_p)) glEnd() glColor3f(0.0, 0.0, 0.6) glBegin(GL_LINES) glVertex3f(*(zero_tx)) glVertex3f(*(mat * z_n)) glEnd() # bounding box vertices i = 0 glColor3f(1.0, 1.0, 1.0) series1 = (-0.5, -0.3, -0.1, 0.1, 0.3, 0.5) series2 = (-0.5, 0.5) z = 0 for x in series1: for y in series2: bb[i][:] = x, y, z bb[i] = mat * bb[i] i += 1 for y in series1: for x in series2: bb[i][:] = x, y, z bb[i] = mat * bb[i] i += 1 # bounding box drawing glLineWidth(1.0) glLineStipple(1, 0xAAAA) glEnable(GL_LINE_STIPPLE) for i in range(0, 24, 2): glBegin(GL_LINE_STRIP) glVertex3f(*bb[i]) glVertex3f(*bb[i + 1]) glEnd() # MAYBE WE SHOULD CONNECT ITERATION FOR ALL PROCESS TO DECREASE # TIME? ######## # points if vs: if data_vector: glPointSize(3.0) glColor3f(0.8, 0.9, 1.0) for i, matrix in enumerate(data_matrix): glBegin(GL_POINTS) k = i if i > verlen: k = verlen for vert in data_vector[k]: vec_corrected = data_matrix[i] * vert glVertex3f(*vec_corrected) #print ('рисовальня', matrix, vec_corrected) glEnd() glPointSize(3.0) ####### # lines if data_edges and data_vector: glColor3f(coloa, colob, coloc) glLineWidth(1.0) glEnable(edgeholy) for i, matrix in enumerate(data_matrix): # object k = i if i > verlen: # filter to share objects k = verlen for line in data_edges[k]: # line if max(line) > verlen_every[k]: line = data_edges[k][-1] glBegin(edgeline) for point in line: # point vec_corrected = data_matrix[i] * data_vector[k][int(point)] glVertex3f(*vec_corrected) glEnd() glPointSize(1.75) glLineWidth(1.0) glDisable(edgeholy) ####### # polygons vectorlight = Vector((-0.66, -0.66, -0.66)) if data_polygons and data_vector: glLineWidth(1.0) glEnable(polyholy) for i, matrix in enumerate(data_matrix): # object k = i if i > verlen: k = verlen oblen = len(data_polygons[k]) for j, pol in enumerate(data_polygons[k]): if max(pol) > verlen_every[k]: pol = data_edges[k][-1] j = len(data_edges[k]) - 1 if shade: normal_no_ = mathutils.geometry.normal( data_vector[k][pol[0]], data_vector[k][pol[1]], data_vector[k][pol[2]]) normal_no = (normal_no_.angle(vectorlight, 0)) / math.pi randa = (normal_no * coloa) - 0.1 randb = (normal_no * colob) - 0.1 randc = (normal_no * coloc) - 0.1 else: randa = ((j / oblen) + coloa) / 2.5 randb = ((j / oblen) + colob) / 2.5 randc = ((j / oblen) + coloc) / 2.5 if len(pol) > 4: glBegin(GL_TRIANGLES) glColor4f(randa + 0.2, randb + 0.2, randc + 0.2, 0.5) #glColor3f(randa+0.2, randb+0.2, randc+0.2) v = [data_vector[k][i] for i in pol] tess_poly = mathutils.geometry.tessellate_polygon([v]) for a, b, c in tess_poly: glVertex3f(*(data_matrix[i] * v[a])) glVertex3f(*(data_matrix[i] * v[b])) glVertex3f(*(data_matrix[i] * v[c])) elif len(pol) == 4: glBegin(GL_POLYGON) glColor3f(randa + 0.2, randb + 0.2, randc + 0.2) for point in pol: vec_corrected = data_matrix[i] * data_vector[k][int( point)] glVertex3f(*vec_corrected) else: glBegin(GL_TRIANGLES) glColor3f(randa + 0.2, randb + 0.2, randc + 0.2) for point in pol: vec_corrected = data_matrix[i] * data_vector[k][int( point)] glVertex3f(*vec_corrected) glEnd() glPointSize(1.75) glLineWidth(1.0) glDisable(polyholy) # for future bezier drawing - to remake #if data_edges and data_vector and bezier: # here 3 lines that i must understand #from bpy_extras.view3d_utils import location_3d_to_region_2d #region = context.region #region_data = context.region_data #glEnable(GL_BLEND) #glColor4f(1, 0, 0, 0.5) #glLineWidth(1.0) #glBegin(GL_LINE_STRIP) #for i in range(current_frame): #glVertex2f(*location_3d_to_region_2d(region, region_data, (math.sin(i / 10), 0, i / 10)).to_tuple()) #glEnd() #glDisable(GL_BLEND) ####### # matrix if data_matrix and not data_vector: for mat in data_matrix: draw_matrix(mat)
def update(self): if 'Vertices' in self.inputs and self.inputs['Vertices'].links: verts = SvGetSocketAnyType(self, self.inputs['Vertices']) if 'PolyEdge' in self.inputs and self.inputs['PolyEdge'].links: poly_edge = SvGetSocketAnyType(self, self.inputs['PolyEdge']) polyIn = True else: polyIn = False poly_edge = repeat_last([[]]) verts_out = [] poly_edge_out = [] item_order = [] polyOutput = bool(polyIn and 'PolyEdge' in self.outputs and self.outputs['PolyEdge'].links) orderOutput = bool('Item order' in self.outputs and self.outputs['Item order'].links) vertOutput = bool('Vertices' in self.outputs and self.outputs['Vertices'].links) if not any((vertOutput, orderOutput, polyOutput)): 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 polyOutput: 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 orderOutput: item_order.append([i[-1] for i in s_v]) if self.mode == 'DIST': if 'Base Point' in self.inputs and self.inputs[ 'Base Point'].links: base_points = SvGetSocketAnyType(self, self.inputs['Base Point']) 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 polyOutput: 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 orderOutput: item_order.append([i[-1] for i in s_v]) if self.mode == 'AXIS': if 'Mat' in self.inputs and self.inputs['Mat'].links: mat = Matrix_generate( SvGetSocketAnyType(self, self.inputs['Mat'])) 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 polyOutput: 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 orderOutput: item_order.append([i[-1] for i in s_v]) if self.mode == 'USER': if 'Index Data' in self.inputs and self.inputs[ 'Index Data'].links: index = SvGetSocketAnyType(self, self.inputs['Index Data']) 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 polyOutput: 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 orderOutput: item_order.append([i[-1] for i in s_v]) if vertOutput: SvSetSocketAnyType(self, 'Vertices', verts_out) if polyOutput: SvSetSocketAnyType(self, 'PolyEdge', poly_edge_out) if orderOutput: SvSetSocketAnyType(self, 'Item order', item_order)
def update(self): if self.outputs['Centers'].links or self.outputs['Normals'].links or \ self.outputs['Origins'].links or self.outputs['Norm_abs'].links: if 'Polygons' in self.inputs and 'Vertices' in self.inputs \ and self.inputs['Polygons'].links and self.inputs['Vertices'].links: pols_ = SvGetSocketAnyType(self, self.inputs['Polygons']) vers_tupls = SvGetSocketAnyType(self, self.inputs['Vertices']) vers_vects = Vector_generate(vers_tupls) # make mesh temp утилитарно - удалить в конце mat_collect = [] normals_out = [] origins = [] norm_abs_out = [] for verst, versv, pols in zip(vers_tupls, vers_vects, pols_): # medians в векторах medians = [] normals = [] centrs = [] norm_abs = [] for p in pols: # medians # it calcs middle point of opposite edges, # than finds length vector between this two points v0 = versv[p[0]] v1 = versv[p[1]] v2 = versv[p[2]] lp = len(p) if lp >= 4: l = ((lp - 2) // 2) + 2 v3 = versv[p[l]] poi_2 = (v2 + v3) / 2 # normals norm = geometry.normal(v0, v1, v2, v3) normals.append(norm) else: poi_2 = v2 # normals norm = geometry.normal(v0, v1, v2) normals.append(norm) poi_1 = (v0 + v1) / 2 vm = poi_2 - poi_1 medians.append(vm) # centrs x, y, z = zip(*[verst[poi] for poi in p]) x, y, z = sum(x) / len(x), sum(y) / len(y), sum( z) / len(z) current_center = Vector((x, y, z)) centrs.append(current_center) # normal absolute !!! # это совершенно нормально!!! ;-) norm_abs.append(current_center + norm) norm_abs_out.append(norm_abs) origins.append(centrs) normals_out.extend(normals) mat_collect_ = [] for cen, med, nor in zip(centrs, medians, normals): loc = Matrix.Translation(cen) # need better solution for Z,Y vectors + may be X vector correction vecz = Vector((0, 1e-6, 1)) q_rot0 = vecz.rotation_difference( nor).to_matrix().to_4x4() q_rot2 = nor.rotation_difference( vecz).to_matrix().to_4x4() vecy = Vector((1e-6, 1, 0)) * q_rot2 q_rot1 = vecy.rotation_difference( med).to_matrix().to_4x4() # loc is matrix * rot vector * rot vector M = loc * q_rot1 * q_rot0 lM = [j[:] for j in M] mat_collect_.append(lM) mat_collect.extend(mat_collect_) SvSetSocketAnyType(self, 'Centers', mat_collect) SvSetSocketAnyType(self, 'Norm_abs', Vector_degenerate(norm_abs_out)) SvSetSocketAnyType(self, 'Origins', Vector_degenerate(origins)) SvSetSocketAnyType(self, 'Normals', Vector_degenerate([normals_out]))
def update(self): if not 'centers' in self.outputs: return if 'vecLine' in self.inputs and 'vecPlane' in self.inputs \ and 'edgPlane' in self.inputs: print(self.name, 'is starting') if self.inputs['vecLine'].links and self.inputs['vecPlane'].links \ and self.inputs['edgPlane'].links: if self.bindCircle: circle = [ (Vector((sin(radians(i)),cos(radians(i)),0))*self.circle_rad)/4 \ for i in range(0,360,30) ] vec = self.inputs['vecLine'].sv_get() vecplan = self.inputs['vecPlane'].sv_get() edgplan = self.inputs['edgPlane'].sv_get() thick = self.inputs['thick'].sv_get()[0][0] sinuso60 = 0.8660254037844386 sinuso60_minus = 0.133974596 sinuso30 = 0.5 sinuso45 = 0.7071067811865475 thick_2 = thick / 2 thick_3 = thick / 3 thick_6 = thick / 6 threshold = self.threshold if 'vecContr' in self.inputs and self.inputs['vecContr'].links: vecont = self.inputs['vecContr'].sv_get() edgcont = self.inputs['edgContr'].sv_get() vec_cont = Vector_generate(vecont) loc_cont = [[i[0]] for i in vec_cont] norm_cont = [[NM(i[0], i[len(i) // 2], i[-1])] for i in vec_cont] # довести до ума else: vec_cont = [] if 'vecTube' in self.inputs and self.inputs['vecTube'].links: vectube = self.inputs['vecTube'].sv_get() vec_tube = Vector_generate(vectube) tube_radius = self.inputs['radTube'].sv_get()[0][0] circle_tube = [ (Vector((sin(radians(i)),cos(radians(i)),0))*tube_radius) \ for i in range(0,360,15) ] else: vec_tube = [] outeup = [] outelo = [] vupper = [] vlower = [] centers = [] vec_ = Vector_generate(vec) vecplan_ = Vector_generate(vecplan) for centersver, vecp, edgp in zip(vecplan, vecplan_, edgplan): tubes_flag_bed_solution_i_know = False newinds1 = edgp.copy() newinds2 = edgp.copy() vupperob = vecp.copy() vlowerob = vecp.copy() deledges1 = [] deledges2 = [] # to define bounds x = [i[0] for i in vecp] y = [i[1] for i in vecp] z = [i[2] for i in vecp] m1x, m2x, m1y, m2y, m1z, m2z = max(x), min(x), max(y), min( y), max(z), min(z) l = Vector( (sum(x) / len(x), sum(y) / len(y), sum(z) / len(z))) n_select = [vecp[0], vecp[len(vecp) // 2], vecp[-1]] # довести до ума n_select.sort(key=lambda x: sum(x[:]), reverse=False) n_ = NM(n_select[0], n_select[1], n_select[2]) n_.normalize() # а виновта ли нормаль? if n_[0] < 0: n = n_ * -1 else: n = n_ cen = [sum(i) for i in zip(*centersver)] centers.append(Vector(cen) / len(centersver)) k = 0 lenvep = len(vecp) # KDtree collections closest to join edges to sockets tree = KDT.KDTree(lenvep) for i, v in enumerate(vecp): tree.insert(v, i) tree.balance() # vertical edges iterations # every edge is object - two points, one edge for v in vec_: # sort vertices by Z value # find two vertices - one lower, two upper vlist = [v[0], v[1]] vlist.sort(key=lambda x: x[2], reverse=False) # flip if coplanar to enemy plane # flip plane coplanar if vec_cont: fliped = self.get_coplanar(v[0], loc_cont, norm_cont, vec_cont) else: fliped = False shortedge = (vlist[1] - vlist[0]).length if fliped: two, one = vlist else: one, two = vlist # coplanar to owner cop = abs(D2P(one, l, n)) # defining bounds inside = one[0]<m1x and one[0]>m2x and one[1]<m1y and one[1]>m2y \ and one[2]<=m1z and one[2]>=m2z # if in bounds and coplanar do: #print(self.name,l, cop, inside) if cop < 0.001 and inside and shortedge > thick * threshold: ''' huge calculations. if we can reduce... ''' # find shift for thickness in sockets diry = two - one diry.normalize() # solution for vertical wafel - cool but not in diagonal case # angle = radians(degrees(atan(n.y/n.x))+90) dirx_ = self.rotation_on_axis(diry, n, radians(90)) dirx = dirx_ * thick_2 # вектор, индекс, расстояние # запоминаем порядок находим какие удалить рёбра # делаем выборку левая-правая точка nearv_1, near_1 = tree.find(one)[:2] nearv_2, near_2 = tree.find(two)[:2] # indexes of two nearest points # удалить рёбра что мешают спать заодно en_0, en_1, de1 = self.calc_indexes(edgp, near_1) deledges1.extend(de1) en_2, en_3, de2 = self.calc_indexes(edgp, near_2) deledges2.extend(de2) # print(vecp, one, dirx, en_0, en_1) # left-right indexes and vectors # с учётом интерполяций по высоте l1, r1, lz1, rz1 = \ self.calc_leftright(vecp, one, dirx, en_0, en_1, thick_2, diry) l2, r2, lz2, rz2 = \ self.calc_leftright(vecp, two, dirx, en_2, en_3, thick_2, diry) # print(left2, right2, l2, r2, lz2, rz2) # средняя точка и её смещение по толщине материала three = (one - two) / 2 + two if self.rounded: '''рёбра''' # пазы формируем независимо от верх низ outeob1 = [[lenvep + k + 8, lenvep + k], [lenvep + k + 1, lenvep + k + 2], [lenvep + k + 2, lenvep + k + 3], [lenvep + k + 3, lenvep + k + 4], [lenvep + k + 4, lenvep + k + 5], [lenvep + k + 5, lenvep + k + 6], [lenvep + k + 6, lenvep + k + 7], [lenvep + k + 7, lenvep + k + 8], [lenvep + k + 9, lenvep + k + 1]] outeob2 = [[lenvep + k, lenvep + k + 1], [lenvep + k + 1, lenvep + k + 2], [lenvep + k + 2, lenvep + k + 3], [lenvep + k + 3, lenvep + k + 4], [lenvep + k + 4, lenvep + k + 5], [lenvep + k + 5, lenvep + k + 6], [lenvep + k + 6, lenvep + k + 7], [lenvep + k + 7, lenvep + k + 8], [lenvep + k + 8, lenvep + k + 9]] # наполнение списков lenvep = length(vecp) newinds1.extend([[l1, lenvep + k], [lenvep + k + 9, r1]]) newinds2.extend([[l2, lenvep + k + 9], [lenvep + k, r2]]) '''Вектора''' round1 = diry * thick_3 round2 = diry * thick_3 * sinuso30 round2_ = dirx / 3 + dirx * (2 * sinuso60 / 3) round3 = diry * thick_3 * sinuso60_minus round3_ = dirx / 3 + dirx * (2 * sinuso30 / 3) round4 = dirx / 3 vupperob.extend([ lz2, three + round1 - dirx, three + round2 - round2_, three + round3 - round3_, three - round4, three + round4, three + round3 + round3_, three + round2 + round2_, three + round1 + dirx, rz2 ]) vlowerob.extend([ rz1, three - round1 - dirx, three - round2 - round2_, three - round3 - round3_, three - round4, three + round4, three - round3 + round3_, three - round2 + round2_, three - round1 + dirx, lz1 ]) k += 10 else: '''рёбра''' # пазы формируем независимо от верх низ outeob1 = [[lenvep + k, lenvep + k + 1], [lenvep + k + 1, lenvep + k + 2], [lenvep + k + 2, lenvep + k + 3]] outeob2 = [[lenvep + k, lenvep + k + 1], [lenvep + k + 1, lenvep + k + 2], [lenvep + k + 2, lenvep + k + 3]] # наполнение списков lenvep = length(vecp) newinds1.extend([[l1, lenvep + k], [lenvep + k + 3, r1]]) newinds2.extend([[l2, lenvep + k + 3], [lenvep + k, r2]]) '''Вектора''' vupperob.extend( [lz2, three - dirx, three + dirx, rz2]) vlowerob.extend( [rz1, three + dirx, three - dirx, lz1]) k += 4 newinds1.extend(outeob1) newinds2.extend(outeob2) if self.bindCircle: CP = self.circl_place if CP == 'Midl': crcl_cntr = IL2P(one, two, Vector( (0, 0, 0)), Vector((0, 0, -1))) elif CP == 'Up' and not fliped: crcl_cntr = two - diry * self.circle_rad * 2 elif CP == 'Down' and not fliped: crcl_cntr = one + diry * self.circle_rad * 2 elif CP == 'Up' and fliped: crcl_cntr = one + diry * self.circle_rad * 2 elif CP == 'Down' and fliped: crcl_cntr = two - diry * self.circle_rad * 2 # forgot howto 'else' in line iteration? outeob1 = [[ lenvep + k + i, lenvep + k + i + 1 ] for i in range(0, 11)] outeob1.append([lenvep + k, lenvep + k + 11]) outeob2 = [[ lenvep + k + i, lenvep + k + i + 1 ] for i in range(12, 23)] outeob2.append( [lenvep + k + 12, lenvep + k + 23]) newinds1.extend(outeob1 + outeob2) newinds2.extend(outeob1 + outeob2) mat_rot_cir = n.rotation_difference( Vector((0, 0, 1))).to_matrix().to_4x4() circle_to_add_1 = [vecir*mat_rot_cir+crcl_cntr+ \ dirx_*self.circle_rad for vecir in circle ] circle_to_add_2 = [vecir*mat_rot_cir+crcl_cntr- \ dirx_*self.circle_rad for vecir in circle ] vupperob.extend(circle_to_add_1 + circle_to_add_2) vlowerob.extend(circle_to_add_1 + circle_to_add_2) k += 24 if vec_tube and not tubes_flag_bed_solution_i_know: for v in vec_tube: crcl_cntr = IL2P(v[0], v[1], l, n) if crcl_cntr: inside = crcl_cntr[0]<m1x and crcl_cntr[0]>m2x and crcl_cntr[1]<m1y \ and crcl_cntr[1]>m2y and crcl_cntr[2]<=m1z and crcl_cntr[2]>=m2z if inside: outeob = [[ lenvep + k + i, lenvep + k + i + 1 ] for i in range(0, 23)] outeob.append( [lenvep + k, lenvep + k + 23]) newinds1.extend(outeob) newinds2.extend(outeob) mat_rot_cir = n.rotation_difference( Vector( (0, 0, 1))).to_matrix().to_4x4() circle_to_add = [ vecir * mat_rot_cir + crcl_cntr for vecir in circle_tube ] vupperob.extend(circle_to_add) vlowerob.extend(circle_to_add) k += 24 tubes_flag_bed_solution_i_know = True elif cop < 0.001 and inside and shortedge <= thick * threshold: vupperob.extend([one, two]) vlowerob.extend([one, two]) newinds1.append([lenvep + k, lenvep + k + 1]) newinds2.append([lenvep + k, lenvep + k + 1]) k += 2 del tree for e in deledges1: if e in newinds1: newinds1.remove(e) for e in deledges2: if e in newinds2: newinds2.remove(e) if vupperob or vlowerob: outeup.append(newinds2) outelo.append(newinds1) vupper.append(vupperob) vlower.append(vlowerob) vupper = Vector_degenerate(vupper) vlower = Vector_degenerate(vlower) centers = Vector_degenerate([centers]) if 'vertUp' in self.outputs and self.outputs['vertUp'].links: out = dataCorrect(vupper) SvSetSocketAnyType(self, 'vertUp', out) if 'edgeUp' in self.outputs and self.outputs['edgeUp'].links: SvSetSocketAnyType(self, 'edgeUp', outeup) if 'vertLo' in self.outputs and self.outputs['vertLo'].links: SvSetSocketAnyType(self, 'vertLo', vlower) if 'edgeLo' in self.outputs and self.outputs['edgeLo'].links: SvSetSocketAnyType(self, 'edgeLo', outelo) if 'centers' in self.outputs and self.outputs['centers'].links: SvSetSocketAnyType(self, 'centers', centers) print(self.name, 'is finishing')
def update(self): # достаём два слота - вершины и полики if 'Vertices' in self.outputs and self.outputs['Vertices'].links: if (self.inputs['PolsR'].links and self.inputs['VersR'].links and self.inputs['VersD'].links and self.inputs['PolsD'].links): if self.inputs['Z_Coef'].links: z_coef = SvGetSocketAnyType(self, self.inputs['Z_Coef'])[0] else: z_coef = [] polsR = SvGetSocketAnyType( self, self.inputs['PolsR'])[0] # recipient one object [0] versR = SvGetSocketAnyType( self, self.inputs['VersR'])[0] # recipient polsD = SvGetSocketAnyType( self, self.inputs['PolsD']) # donor many objects [:] versD_ = SvGetSocketAnyType(self, self.inputs['VersD']) # donor versD = Vector_generate(versD_) ##### it is needed for normals of vertices new_me = bpy.data.meshes.new('recepient') new_me.from_pydata(versR, [], polsR) new_me.update(calc_edges=True) new_ve = new_me.vertices #print (new_ve[0].normal, 'normal') for i, vD in enumerate(versD): pD = polsD[i] n_verts = len(vD) n_faces = len(pD) xx = [x[0] for x in vD] x0 = (self.width_coef) / (max(xx) - min(xx)) yy = [y[1] for y in vD] y0 = (self.width_coef) / (max(yy) - min(yy)) zz = [z[2] for z in vD] zzz = (max(zz) - min(zz)) if zzz: z0 = 1 / zzz else: z0 = 0 #print (x0, y0, z0) vers_out = [] pols_out = [] for j, pR in enumerate(polsR): last = len(pR) - 1 vs = [new_ve[v] for v in pR] # new_ve - temporery data if z_coef: if j < len(z_coef): z1 = z0 * z_coef[j] else: z1 = z0 new_vers = [] new_pols = [] for v in vD: new_vers.append( self.lerp3(vs[0], vs[1], vs[2], vs[last], v, x0, y0, z1)) for p in pD: new_pols.append([id for id in p]) pols_out.append(new_pols) vers_out.append(new_vers) bpy.data.meshes.remove(new_me) # cleaning and washing del (new_ve) #print (Vector_degenerate(vers_out)) output = Vector_degenerate(vers_out) #print (output) if 'Vertices' in self.outputs and self.outputs[ 'Vertices'].links: SvSetSocketAnyType(self, 'Vertices', output) if 'Poligons' in self.outputs and self.outputs[ 'Poligons'].links: SvSetSocketAnyType(self, 'Poligons', pols_out)
def update(self): if 'vec' in self.inputs and 'edg' in self.inputs: print(self.name, 'is starting') if self.inputs['vec'].links and self.inputs['edg'].links: vec = self.inputs['vec'].sv_get() edg = self.inputs['edg'].sv_get() vecplan = self.inputs['vecplan'].sv_get() edgplan = self.inputs['edgplan'].sv_get() loc = self.inputs['loc'].sv_get() norm = self.inputs['norm'].sv_get() thick = self.inputs['thick'].sv_get()[0][0] sinuso60 = 0.8660254037844386 sinuso60_minus = 0.133974596 sinuso30 = 0.5 sinuso45 = 0.7071067811865475 if 'loccont' in self.inputs and self.inputs['loccont'].links and \ 'normcont' in self.inputs and self.inputs['normcont'].links: vecont = self.inputs['vecont'].sv_get() loccont = self.inputs['loccont'].sv_get() normcont = self.inputs['normcont'].sv_get() vec_cont = Vector_generate(vecont) loc_cont = Vector_generate(loccont) norm_cont = Vector_generate(normcont) else: norm_cont = [[Vector((0,0,1)) for i in range(len(norm[0]))]] loc_cont = [[Vector((0,0,10000)) for i in range(len(norm[0]))]] vec_cont = [[Vector((1000,0,1))] for i in range(len(norm[0]))] outeup = [] outelo = [] vupper = [] vlower = [] vec_ = Vector_generate(vec) loc_ = Vector_generate(loc) norm_ = Vector_generate(norm) vecplan_ = Vector_generate(vecplan) #print(self.name, 'veriables: \n', \ # vec_,'\n', # vecplan_,'\n', # loc_,'\n', # loc_cont) for l,n,vecp, edgp in zip(loc_[0],norm_[0],vecplan_,edgplan): newinds1 = edgp.copy() newinds2 = edgp.copy() vupperob = vecp.copy() vlowerob = vecp.copy() deledges1 = [] deledges2 = [] k = 0 lenvep = len(vecp) # KDtree collections closest to join edges to sockets tree = KDT.KDTree(lenvep) for i,v in enumerate(vecp): tree.insert(v,i) tree.balance() # to define bounds x = [i[0] for i in vecp] y = [i[1] for i in vecp] m1x,m2x,m1y,m2y = max(x), min(x), max(y), min(y) # vertical edges iterations # every edge is object - two points, one edge for v in vec_: # sort vertices by Z value # find two vertices - one lower, two upper vlist = [v[0],v[1]] vlist.sort(key=lambda x: x[2], reverse=False) # flip if coplanar to enemy plane # flip plane coplanar fliped = self.get_coplanar(v[0], loc_cont,norm_cont, vec_cont) if fliped: two, one = vlist else: one, two = vlist # coplanar to owner cop = abs(D2P(one,l,n)) # defining bounds inside = one[0]<m1x and one[0]>m2x and one[1]<m1y and one[1]>m2y # if in bounds and coplanar do: #print(self.name,l, cop, inside) if cop < 0.001 and inside: ''' huge calculations. if we can reduce... ''' # find shift for thickness in sockets angle = radians(degrees(atan(n.y/n.x))+90) thick_2 = thick/2 direction = Vector((cos(angle),sin(angle),0))*thick_2 #matr = Euler((0,0,angle),'YZX').to_matrix().to_4x4() #matr.translation = #direction = matr # вектор, индекс, расстояние # запоминаем порядок # находим какие удалить рёбра # делаем выборку левая-правая точка nearv_1, near_1 = tree.find(one)[:2] nearv_2, near_2 = tree.find(two)[:2] # indexes of two nearest points # удалить рёбра что мешают спать заодно en_0, en_1, de1 = self.calc_indexes(edgp, near_1) deledges1.extend(de1) en_2, en_3, de2 = self.calc_indexes(edgp, near_2) deledges2.extend(de2) # old delete # en_0,en_1 = [[t for t in i if t != near_1] for i in edgp if near_1 in i] # en_2,en_3 = [[t for t in i if t != near_2] for i in edgp if near_2 in i] # print(vecp, one, direction, en_0, en_1) # left-right indexes and vectors # с учётом интерполяций по высоте left1, right1, l1, r1, lz1, rz1 = \ self.calc_leftright(vecp, one, direction, en_0, en_1, thick_2) left2, right2, l2, r2, lz2, rz2 = \ self.calc_leftright(vecp, two, direction, en_2, en_3, thick_2) # средняя точка и её смещение по толщине материала three = (one-two)/2 + two if self.rounded: '''рёбра''' if fliped: doflip = -1 else: doflip = 1 # пазы формируем независимо от верх низ outeob1 = [[lenvep+k+8,lenvep+k],[lenvep+k+1,lenvep+k+2], [lenvep+k+2,lenvep+k+3],[lenvep+k+3,lenvep+k+4], [lenvep+k+4,lenvep+k+5],[lenvep+k+5,lenvep+k+6], [lenvep+k+6,lenvep+k+7],[lenvep+k+7,lenvep+k+8], [lenvep+k+9,lenvep+k+1]] outeob2 = [[lenvep+k,lenvep+k+1],[lenvep+k+1,lenvep+k+2], [lenvep+k+2,lenvep+k+3],[lenvep+k+3,lenvep+k+4], [lenvep+k+4,lenvep+k+5],[lenvep+k+5,lenvep+k+6], [lenvep+k+6,lenvep+k+7],[lenvep+k+7,lenvep+k+8], [lenvep+k+8,lenvep+k+9]] # наполнение списков lenvep = length(vecp) newinds1.extend([[l1, lenvep+k], [lenvep+k+9, r1]]) newinds2.extend([[l2, lenvep+k+9], [lenvep+k, r2]]) '''Вектора''' thick_3 = thick/3 thick_6 = thick/6 round1 = Vector((0,0,doflip*thick_3)) round2 = Vector((0,0,doflip*thick_3*sinuso30)) round2_= direction/3 + direction*(2*sinuso60/3) round3 = Vector((0,0,doflip*thick_3*sinuso60_minus)) round3_= direction/3 + direction*(2*sinuso30/3) round4 = direction/3 vupperob.extend([two-direction-Vector((0,0,lz2)), three+round1-direction, three+round2-round2_, three+round3-round3_, three-round4, three+round4, three+round3+round3_, three+round2+round2_, three+round1+direction, two+direction-Vector((0,0,rz2))]) vlowerob.extend([one+direction-Vector((0,0,rz1)), three-round1-direction, three-round2-round2_, three-round3-round3_, three-round4, three+round4, three-round3+round3_, three-round2+round2_, three-round1+direction, one-direction-Vector((0,0,lz1))]) k += 10 else: '''рёбра''' # пазы формируем независимо от верх низ outeob1 = [[lenvep+k,lenvep+k+1],[lenvep+k+1,lenvep+k+2],[lenvep+k+2,lenvep+k+3]] outeob2 = [[lenvep+k,lenvep+k+1],[lenvep+k+1,lenvep+k+2],[lenvep+k+2,lenvep+k+3]] # наполнение списков lenvep = length(vecp) newinds1.extend([[l1, lenvep+k], [lenvep+k+3, r1]]) newinds2.extend([[l2, lenvep+k+3], [lenvep+k, r2]]) '''Вектора''' vupperob.extend([two-direction-Vector((0,0,lz2)), three-direction, three+direction, two+direction-Vector((0,0,rz2))]) vlowerob.extend([one+direction-Vector((0,0,rz1)), three+direction, three-direction, one-direction-Vector((0,0,lz1))]) k += 4 newinds1.extend(outeob1) newinds2.extend(outeob2) del tree for e in deledges1: if e in newinds1: newinds1.remove(e) for e in deledges2: if e in newinds2: newinds2.remove(e) if vupperob or vlowerob: outeup.append(newinds2) outelo.append(newinds1) vupper.append(vupperob) vlower.append(vlowerob) vupper = Vector_degenerate(vupper) vlower = Vector_degenerate(vlower) if 'vupper' in self.outputs and self.outputs['vupper'].links: out = dataCorrect(vupper) SvSetSocketAnyType(self, 'vupper', out) if 'outeup' in self.outputs and self.outputs['outeup'].links: SvSetSocketAnyType(self, 'outeup', outeup) if 'vlower' in self.outputs and self.outputs['vlower'].links: SvSetSocketAnyType(self, 'vlower', vlower) if 'outelo' in self.outputs and self.outputs['outelo'].links: SvSetSocketAnyType(self, 'outelo', outelo) print(self.name, 'is finishing')