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