def assert_sverchok_data_equal(self, data1, data2, precision=None): """ Assert that two arrays of Sverchok data (nested tuples or lists) are equal. Floating-point numbers are compared with specified precision. """ level1 = get_data_nesting_level(data1) level2 = get_data_nesting_level(data2) if level1 != level2: raise AssertionError( "Nesting level of 1st data {} != nesting level of 2nd data {}". format(level1, level2)) def do_assert(d1, d2, idxs): if precision is not None: d1 = round(d1, precision) d2 = round(d2, precision) self.assertEqual(d1, d2, "Data 1 [{}] != Data 2 [{}]".format(idxs, idxs)) if level1 == 0: do_assert(data1, data2, []) return def compare(prev_indicies, item1, item2): step = len(prev_indicies) index = prev_indicies[-1] if step == level1: if index >= len(item1): raise AssertionError( "At {}: index {} >= length of Item 1: {}".format( prev_indicies, index, item1)) if index >= len(item2): raise AssertionError( "At {}: index {} >= length of Item 2: {}".format( prev_indicies, index, item2)) do_assert(item1[index], item2[index], prev_indicies) else: l1 = len(item1) l2 = len(item2) self.assertEquals( l1, l2, "Size of data 1 at level {} != size of data 2".format( step)) for next_idx in range(len(item1[index])): new_indicies = prev_indicies[:] new_indicies.append(next_idx) compare(new_indicies, item1[index], item2[index]) for idx in range(len(data1)): compare([idx], data1, data2)
def process(self): if not self.activate: return origins = self.inputs['Origin'].sv_get() sizes_sq = self.inputs['Size'].sv_get() sizes_x = self.inputs['Size X'].sv_get() sizes_y = self.inputs['Size Y'].sv_get() spot_sizes = self.inputs['Spot Size'].sv_get() spot_blends = self.inputs['Spot Blend'].sv_get() strengths = self.inputs['Strength'].sv_get() colors = self.inputs['Color'].sv_get() if get_data_nesting_level(colors) == 3: colors = colors[0] objects = match_long_repeat([ origins, sizes_sq, sizes_x, sizes_y, strengths, spot_sizes, spot_blends, colors ]) for index, object in enumerate(zip(*objects)): self.make_lamp(index, object) self.remove_non_updated_objects(index) objs = self.get_children() self.outputs['Objects'].sv_set(objs)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surface_s = self.inputs['Surface'].sv_get() knot_s = self.inputs['Knot'].sv_get() count_s = self.inputs['Count'].sv_get() input_level = get_data_nesting_level(surface_s, data_types=(SvSurface,)) flat_output = input_level < 2 surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface,)) knot_s = ensure_nesting_level(knot_s, 3) count_s = ensure_nesting_level(count_s, 3) surfaces_out = [] for surfaces, knots_i, counts_i in zip_long_repeat(surface_s, knot_s, count_s): new_surfaces = [] for surface, knots, counts in zip_long_repeat(surfaces, knots_i, counts_i): surface = SvNurbsSurface.get(surface) if surface is None: raise Exception("One of surfaces is not NURBS") for knot, count in zip_long_repeat(knots, counts): surface = surface.insert_knot(self.direction, knot, count, if_possible=self.if_possible) new_surfaces.append(surface) if flat_output: surfaces_out.extend(new_surfaces) else: surfaces_out.append(new_surfaces) self.outputs['Surface'].sv_set(surfaces_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() in_level = get_data_nesting_level(curve_s, data_types=(SvCurve,)) curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve,)) surface_s = self.inputs['Surface'].sv_get() surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface,)) point_s = self.inputs['Point'].sv_get() point_s = ensure_nesting_level(point_s, 3) vector_s = self.inputs['Vector'].sv_get() vector_s = ensure_nesting_level(vector_s, 3) edges_out = [] trims_out = [] for curves, face_surfaces, points, vectors in zip_long_repeat(curve_s, surface_s, point_s, vector_s): new_edges = [] new_trims = [] for curve, face_surface, point, vector in zip_long_repeat(curves, face_surfaces, points, vectors): if not is_solid_face_surface(face_surface): face_surface = surface_to_freecad(face_surface, make_face=True) # SvFreeCadNurbsSurface projection, trims = self.project(face_surface, curve, point, vector) new_edges.append(projection) new_trims.append(trims) if in_level == 1: edges_out.extend(new_edges) trims_out.extend(new_trims) else: # 2 edges_out.append(new_edges) trims_out.append(new_trims) self.outputs['Curves'].sv_set(edges_out) self.outputs['TrimCurves'].sv_set(trims_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() input_level = get_data_nesting_level(curve_s, data_types=(SvCurve,)) flat_output = input_level < 2 curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve,)) tolerance = self.tolerance curves_out = [] for curves in curve_s: new_curves = [] for curve in curves: curve = SvNurbsCurve.to_nurbs(curve) if curve is None: raise Exception("One of curves is not NURBS") curve = remove_excessive_knots(curve, tolerance=tolerance) new_curves.append(curve) if flat_output: curves_out.extend(new_curves) else: curves_out.append(new_curves) self.outputs['Curve'].sv_set(curves_out)
def the_check(source_data): level = get_data_nesting_level(source_data) if level > 2: raise TypeError( "Too high data nesting level for Number -> Scalar Field conversion: %s" % level) return func(source_data)
def clip_mesh(self, bounds, vertices, edges, faces, fill=False, iterate=None): if iterate is None: iterate = get_data_nesting_level(vertices) > 2 if iterate: vertices_result = [] edges_result = [] faces_result = [] for vertices_item, edges_item, faces_item in zip( vertices, edges, faces): new_vertices, new_edges, new_faces = self.clip_mesh( bounds, vertices_item, edges_item, faces_item, fill=fill, iterate=False) if new_vertices: vertices_result.append(new_vertices) edges_result.append(new_edges) faces_result.append(new_faces) return vertices_result, edges_result, faces_result else: bm = bmesh_from_pydata(vertices, edges, faces) bmesh_clip(bm, bounds, fill) vertices, edges, faces = pydata_from_bmesh(bm) bm.free() return vertices, edges, faces
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() segments_s = self.inputs['Segments'].sv_get() split_s = self.inputs['Split'].sv_get() curves_level = get_data_nesting_level(curve_s, data_types=(SvCurve, )) curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve, )) segments_s = ensure_nesting_level(segments_s, 2) split_s = ensure_nesting_level(split_s, 3) curves_out = [] for curves, segments_i, split_i in zip_long_repeat( curve_s, segments_s, split_s): curves_list = [] for curve, segments, splits in zip_long_repeat( curves, segments_i, split_i): new_curves = [] t_min, t_max = curve.get_u_bounds() if self.mode == 'EVEN': splits = self._cut(t_min, t_max, segments) #splits = [t_min] + splits + [t_max] new_curves = split_curve(curve, splits, self.rescale) if self.join: curves_list.extend(new_curves) else: curves_list.append(new_curves) if curves_level == 2: curves_out.append(curves_list) else: curves_out.extend(curves_list) self.outputs['Curves'].sv_set(curves_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return solids_s = self.inputs['Solid'].sv_get() input_level = get_data_nesting_level(solids_s, data_types=(Part.Shape, )) solids_s = ensure_nesting_level(solids_s, 2, data_types=(Part.Shape, )) thickness_s = self.inputs['Thickness'].sv_get() thickness_s = ensure_nesting_level(thickness_s, 2) if self.inputs['FaceMask'].is_linked: mask_s = self.inputs['FaceMask'].sv_get() mask_s = ensure_nesting_level(mask_s, 3) else: mask_s = [[[True]]] solids_out = [] for params in zip_long_repeat(solids_s, thickness_s, mask_s): new_solids = [] for solid, thickness, mask in zip_long_repeat(*params): new_solid = self.make_solid(solid, thickness, mask) new_solids.append(new_solid) if input_level == 2: solids_out.append(new_solids) else: solids_out.extend(new_solids) self.outputs['Solid'].sv_set(solids_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return face_surfaces_s = self.inputs['SolidFaces'].sv_get() input_level = get_data_nesting_level(face_surfaces_s, data_types=(SvSurface, )) face_surfaces_s = ensure_nesting_level(face_surfaces_s, 3, data_types=(SvSurface, )) solids_out = [] for surfaces_i in face_surfaces_s: new_solids = [] for surfaces in surfaces_i: for i in range(len(surfaces)): if not is_solid_face_surface(surfaces[i]): surfaces[i] = surface_to_freecad(surfaces[i], make_face=True) solid = self.make_solid(surfaces) new_solids.append(solid) if input_level > 2: solids_out.append(new_solids) else: solids_out.extend(new_solids) self.outputs['Solid'].sv_set(solids_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surface_s = self.inputs['Surface'].sv_get() input_level = get_data_nesting_level(surface_s, data_types=(SvSurface, )) flat_output = input_level < 2 surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface, )) tolerance = self.tolerance surfaces_out = [] for surfaces in surface_s: new_surfaces = [] for surface in surfaces: surface = SvNurbsSurface.get(surface) if surface is None: raise Exception("One of surfaces is not NURBS") surface = remove_excessive_knots(surface, self.direction, tolerance=tolerance) new_surfaces.append(surface) if flat_output: surfaces_out.extend(new_surfaces) else: surfaces_out.append(new_surfaces) self.outputs['Surface'].sv_set(surfaces_out)
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() 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) output = OutputData() if self.matching_mode == 'PERFACE': verts_donor_s = [verts_donor_s] faces_donor_s = [faces_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, frame_widths_s, zcoefs_s, zoffsets_s, zrotations_s, wcoefs_s, facerots_s, mask_s]) #self.info("N objects: %s", len(list(zip(*objects)))) for verts_recpt, faces_recpt, verts_donor, faces_donor, frame_widths, zcoefs, zoffsets, zrotations, wcoefs, facerots, mask 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) new = self._process(verts_recpt, faces_recpt, verts_donor, faces_donor, frame_widths, zcoefs, zoffsets, zrotations, wcoefs, facerots, mask) output.verts_out.extend(new.verts_out) output.faces_out.extend(new.faces_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.verts_out = [output.verts_out] output.faces_out = [output.faces_out] self.outputs['Vertices'].sv_set(output.verts_out) self.outputs['Polygons'].sv_set(output.faces_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() omega_s = self.inputs['Omega'].sv_get() input_level = get_data_nesting_level(vertices_s) vertices_s = ensure_nesting_level(vertices_s, 4) omega_s = ensure_nesting_level(omega_s, 2) nested_output = input_level > 3 curves_out = [] points_out = [] for params in zip_long_repeat(vertices_s, omega_s): new_curves = [] new_points = [] for vertices, omega in zip_long_repeat(*params): curve = SvFourierCurve.interpolate(np.array(vertices), omega, metric=self.metric, is_cyclic = self.is_cyclic) amplitudes = [tuple(curve.start)] + curve.coeffs.tolist() new_curves.append(curve) new_points.append(amplitudes) if nested_output: curves_out.append(new_curves) points_out.append(new_points) else: curves_out.extend(new_curves) points_out.extend(new_points) self.outputs['Curve'].sv_set(curves_out) self.outputs['Amplitudes'].sv_set(points_out)
def process(self): if not self.outputs['Vertices'].is_linked: return verts_in = self.inputs['Vertices'].sv_get() iterations_in = self.inputs['Iterations'].sv_get() weights_in = self.inputs['Weights'].sv_get(default=[[None]]) input_level = get_data_nesting_level(verts_in) verts_in = ensure_nesting_level(verts_in, 4) iterations_in = ensure_nesting_level(iterations_in, 2) if self.inputs['Weights'].is_linked: weights_in = ensure_nesting_level(weights_in, 2, data_types=(SvScalarField,)) nested_output = input_level > 3 verts_out = [] for params in zip_long_repeat(verts_in, iterations_in, weights_in): new_verts = [] for verts, iterations, weights in zip_long_repeat(*params): iter_verts = lloyd2d(self.bound_mode, verts, iterations, clip = self.clip, weight_field = weights) new_verts.append(iter_verts) if nested_output: verts_out.append(new_verts) else: verts_out.extend(new_verts) self.outputs['Vertices'].sv_set(verts_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() knot_s = self.inputs['Knot'].sv_get() count_s = self.inputs['Count'].sv_get() input_level = get_data_nesting_level(curve_s, data_types=(SvCurve, )) flat_output = input_level < 2 curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve, )) knot_s = ensure_nesting_level(knot_s, 3) count_s = ensure_nesting_level(count_s, 3) curves_out = [] for curves, knots_i, counts_i in zip_long_repeat( curve_s, knot_s, count_s): new_curves = [] for curve, knots, counts in zip_long_repeat( curves, knots_i, counts_i): curve = SvNurbsCurve.to_nurbs(curve) if curve is None: raise Exception("One of curves is not NURBS") for knot, count in zip_long_repeat(knots, counts): curve = curve.insert_knot(knot, count, if_possible=self.if_possible) new_curves.append(curve) if flat_output: curves_out.extend(new_curves) else: curves_out.append(new_curves) self.outputs['Curve'].sv_set(curves_out)
def process(self): if not any(o.is_linked for o in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get(default=[[]]) level = get_data_nesting_level(vertices_s) if level < 2 or level > 4: raise TypeError( f"Required nesting level is 2 to 4, provided data nesting level is {level}" ) if level == 2: vertices_s = [vertices_s] level = 3 if level == 3: vertices_s = [vertices_s] out_curves = [] for vertices_group in vertices_s: new_curves = [] for vertices in vertices_group: spline = self.build_spline(vertices) curve = SvSplineCurve(spline) new_curves.append(curve) if level == 4: out_curves.append(new_curves) else: out_curves.extend(new_curves) self.outputs['Curve'].sv_set(out_curves)
def process(self): if not any(socket.is_linked for socket in self.outputs): return amplitudes_s = self.inputs['Amplitudes'].sv_get() omega_s = self.inputs['Omega'].sv_get() input_level = get_data_nesting_level(amplitudes_s) amplitudes_s = ensure_nesting_level(amplitudes_s, 4) omega_s = ensure_nesting_level(omega_s, 2) nested_output = input_level > 3 curves_out = [] for params in zip_long_repeat(amplitudes_s, omega_s): new_curves = [] for amplitudes, omega in zip_long_repeat(*params): if len(amplitudes) < 2: raise Exception( "At least 2 amplitude vectors are required") start = np.array(amplitudes[0]) amplitudes = np.array(amplitudes[1:]) curve = SvFourierCurve(omega, start, amplitudes) new_curves.append(curve) if nested_output: curves_out.append(new_curves) else: curves_out.extend(new_curves) self.outputs['Curve'].sv_set(curves_out)
def assert_sverchok_data_equal(self, data1, data2, precision=None, message=None): """ Assert that two arrays of Sverchok data (nested tuples or lists) are equal. Floating-point numbers are compared with specified precision. """ def format_message(text): if message is None: return text else: return f"{text}: {message}" level1 = get_data_nesting_level(data1) level2 = get_data_nesting_level(data2) if level1 != level2: raise AssertionError(format_message(f"Nesting level of 1st data {level1} != nesting level of 2nd data {level2}")) def do_assert(d1, d2, idxs): if precision is not None: d1 = round(d1, precision) d2 = round(d2, precision) self.assertEqual(d1, d2, format_message(f"Data 1 [{idxs}] != Data 2 [{idxs}]")) if level1 == 0: do_assert(data1, data2, []) return def compare(prev_indicies, item1, item2): step = len(prev_indicies) index = prev_indicies[-1] if step == level1: if index >= len(item1): raise AssertionError(format_message(f"At {prev_indicies}: index {index} >= length of Item 1: {item1}")) if index >= len(item2): raise AssertionError(format_message(f"At {prev_indicies}: index {index} >= length of Item 2: {item2}")) do_assert(item1[index], item2[index], prev_indicies) else: l1 = len(item1) l2 = len(item2) self.assertEquals(l1, l2, format_message(f"Size of data 1 at level {step} != size of data 2")) for next_idx in range(len(item1[index])): new_indicies = prev_indicies[:] new_indicies.append(next_idx) compare(new_indicies, item1[index], item2[index]) for idx in range(len(data1)): compare([idx], data1, data2)
def process(self): if not self.outputs['Compound'].is_linked: return if not any(sock.is_linked for sock in self.inputs): return solids_s = self.inputs['Solids'].sv_get(default=[[None]]) curves_s = self.inputs['Curves'].sv_get(default=[[None]]) surfaces_s = self.inputs['Surfaces'].sv_get(default=[[None]]) if self.inputs['Solids'].is_linked: solids_s = ensure_nesting_level(solids_s, 2, data_types=(Part.Shape, )) solids_level = get_data_nesting_level( solids_s, data_types=(Part.Shape, )) else: solids_level = 2 if self.inputs['Curves'].is_linked: curves_s = ensure_nesting_level(curves_s, 2, data_types=(SvCurve, )) curves_level = get_data_nesting_level(curves_s, data_types=(SvCurve, )) else: curves_level = 2 if self.inputs['Surfaces'].is_linked: surfaces_s = ensure_nesting_level(surfaces_s, 2, data_types=(SvSurface, )) surfaces_level = get_data_nesting_level( surfaces_s, data_types=(SvSurface, )) else: surfaces_level = 2 max_level = max(solids_level, curves_level, surfaces_level) compounds_out = [] for solids, curves, surfaces in zip_long_repeat( solids_s, curves_s, surfaces_s): shapes = solids + curves + surfaces shapes = [to_solid(s) for s in shapes if s is not None] compound = Part.Compound(shapes) compounds_out.append(compound) self.outputs['Compound'].sv_set(compounds_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return solids_in = self.inputs['Solids'].sv_get() input_level = get_data_nesting_level(solids_in, data_types=(Part.Shape, )) solids_in = ensure_nesting_level(solids_in, 2, data_types=(Part.Shape, )) include_in = self.inputs['Include'].sv_get(default=[None]) if self.inputs['Include'].is_linked: include_in = ensure_nesting_level(include_in, 3) exclude_in = self.inputs['Exclude'].sv_get(default=[None]) if self.inputs['Exclude'].is_linked: exclude_in = ensure_nesting_level(exclude_in, 3) solids_out = [] solid_srcs_out = [] edge_masks_out = [] edge_srcs_out = [] face_masks_out = [] face_srcs_out = [] for solids, include_idxs, exclude_idxs in zip_long_repeat( solids_in, include_in, exclude_in): result = self._process(solids, include_idxs, exclude_idxs) # Just debugging # solid_level = get_data_nesting_level(result.solid, data_types=(Part.Shape,)) # mask_level = get_data_nesting_level(result.edge_mask) # map_level = get_data_nesting_level(result.edge_map) # src_level = get_data_nesting_level(result.solid_map) # print(f"Input {input_level}, merge {self.merge_result} => So {solid_level}, Mask {mask_level}, Map {map_level}, Src {src_level}") if input_level == 1 or self.merge_result: solids_out.extend(result.solid) solid_srcs_out.extend(result.solid_map) edge_masks_out.extend(result.edge_mask) edge_srcs_out.extend(result.edge_map) face_masks_out.extend(result.face_mask) face_srcs_out.extend(result.face_map) else: solids_out.append(result.solid) solid_srcs_out.append(result.solid_map) edge_masks_out.append(result.edge_mask) edge_srcs_out.append(result.edge_map) face_masks_out.append(result.face_mask) face_srcs_out.append(result.face_map) self.outputs['Solid'].sv_set(solids_out) self.outputs['SolidSources'].sv_set(solid_srcs_out) self.outputs['EdgesMask'].sv_set(edge_masks_out) self.outputs['EdgeSources'].sv_set(edge_srcs_out) self.outputs['FacesMask'].sv_set(face_masks_out) self.outputs['FaceSources'].sv_set(face_srcs_out)
def test_fuse_1(self): "Input level 1, Merge = On" box1 = self._make_box_node(0, 0, 0, size=2) box2 = self._make_box_node(1, 1, 1, size=2) join = self._make_list_join() self.tree.links.new(box1.outputs[0], join.inputs[0]) self.tree.links.new(box2.outputs[0], join.inputs[1]) self.tree.links.new(join.outputs[0], self.node.inputs["Solids"]) self.node.refine_solid = False self.node.process() out = self.get_output_data("Solid") out_level = get_data_nesting_level(out, data_types=(Part.Shape, )) self.assertEquals(out_level, 1) out_len = len(out) self.assertEquals(out_len, 1) map = self.get_output_data("SolidSources") self.assert_sverchok_data_equal(map, [[0, 1]]) mask = self.get_output_data("EdgesMask") mask_level = get_data_nesting_level(mask) self.assertEqual(mask_level, 2) self.assertEqual(len(mask[0]), 30) map = self.get_output_data("EdgeSources") map_level = get_data_nesting_level(map) self.assertEqual(map_level, 3) self.assertEqual(len(map[0]), 30) mask = self.get_output_data("FacesMask") mask_level = get_data_nesting_level(mask) self.assertEqual(mask_level, 2) self.assertEqual(len(mask[0]), 12) map = self.get_output_data("FaceSources") map_level = get_data_nesting_level(map) self.assertEqual(map_level, 3) self.assertEqual(len(map[0]), 12)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surface_in = self.inputs['SolidFace'].sv_get() sites_in = self.inputs['Sites'].sv_get() iterations_in = self.inputs['Iterations'].sv_get() thickness_in = self.inputs['Thickness'].sv_get() weights_in = self.inputs['Weights'].sv_get(default=[[None]]) surface_in = ensure_nesting_level(surface_in, 2, data_types=(SvSurface, )) input_level = get_data_nesting_level(sites_in) sites_in = ensure_nesting_level(sites_in, 4) iterations_in = ensure_nesting_level(iterations_in, 2) thickness_in = ensure_nesting_level(thickness_in, 2) if self.inputs['Weights'].is_linked: weights_in = ensure_nesting_level(weights_in, 2, data_types=(SvScalarField, )) nested_output = input_level > 3 verts_out = [] uvpoints_out = [] for params in zip_long_repeat(surface_in, sites_in, iterations_in, thickness_in, weights_in): new_verts = [] new_uvpoints = [] for surface, sites, iterations, thickness, weights in zip_long_repeat( *params): if is_solid_face_surface(surface): fc_face = surface.face else: fc_face = surface_to_freecad(surface, make_face=True).face uvpoints, sites = lloyd_on_fc_face(fc_face, sites, thickness, iterations, weight_field=weights) new_verts.append(sites) new_uvpoints.append(uvpoints) if nested_output: verts_out.append(new_verts) uvpoints_out.append(new_uvpoints) else: verts_out.extend(new_verts) uvpoints_out.extend(new_uvpoints) self.outputs['Sites'].sv_set(verts_out) self.outputs['UVPoints'].sv_set(uvpoints_out)
def process(self): if not any(output.is_linked for output in self.outputs): return solid_s = self.inputs['Solid'].sv_get() if self.criteria_type in {'SOLID_DISTANCE', 'SOLID_INSIDE'}: tool_s = self.inputs['Tool'].sv_get() tool_s = ensure_nesting_level(tool_s, 2, data_types=(Part.Shape, )) else: tool_s = [[None]] direction_s = self.inputs['Direction'].sv_get() center_s = self.inputs['Center'].sv_get() percent_s = self.inputs['Percent'].sv_get() radius_s = self.inputs['Radius'].sv_get() precision_s = self.inputs['Precision'].sv_get() input_level = get_data_nesting_level(solid_s, data_types=(Part.Shape, )) solid_s = ensure_nesting_level(solid_s, 2, data_types=(Part.Shape, )) direction_s = ensure_nesting_level(direction_s, 3) center_s = ensure_nesting_level(center_s, 3) percent_s = ensure_nesting_level(percent_s, 2) radius_s = ensure_nesting_level(radius_s, 2) precision_s = ensure_nesting_level(precision_s, 2) vertex_mask_out = [] edge_mask_out = [] face_mask_out = [] for objects in zip_long_repeat(solid_s, tool_s, direction_s, center_s, percent_s, radius_s, precision_s): vertex_mask_new = [] edge_mask_new = [] face_mask_new = [] for solid, tool, direction, center, percent, radius, precision in zip_long_repeat( *objects): vertex_mask, edge_mask, face_mask = self.calc_mask( solid, tool, precision, direction, center, percent, radius) vertex_mask_new.append(vertex_mask) edge_mask_new.append(edge_mask) face_mask_new.append(face_mask) if input_level == 2: vertex_mask_out.append(vertex_mask_new) edge_mask_out.append(edge_mask_new) face_mask_out.append(face_mask_new) else: vertex_mask_out.extend(vertex_mask_new) edge_mask_out.extend(edge_mask_new) face_mask_out.extend(face_mask_new) self.outputs['VerticesMask'].sv_set(vertex_mask_out) self.outputs['EdgesMask'].sv_set(edge_mask_out) self.outputs['FacesMask'].sv_set(face_mask_out)
def assert_sverchok_data_equal(self, data1, data2, precision=None): """ Assert that two arrays of Sverchok data (nested tuples or lists) are equal. Floating-point numbers are compared with specified precision. """ level1 = get_data_nesting_level(data1) level2 = get_data_nesting_level(data2) if level1 != level2: raise AssertionError("Nesting level of 1st data {} != nesting level of 2nd data {}".format(level1, level2)) def do_assert(d1, d2, idxs): if precision is not None: d1 = round(d1, precision) d2 = round(d2, precision) self.assertEqual(d1, d2, "Data 1 [{}] != Data 2 [{}]".format(idxs, idxs)) if level1 == 0: do_assert(data1, data2, []) return def compare(prev_indicies, item1, item2): step = len(prev_indicies) index = prev_indicies[-1] if step == level1: if index >= len(item1): raise AssertionError("At {}: index {} >= length of Item 1: {}".format(prev_indicies, index, item1)) if index >= len(item2): raise AssertionError("At {}: index {} >= length of Item 2: {}".format(prev_indicies, index, item2)) do_assert(item1[index], item2[index], prev_indicies) else: l1 = len(item1) l2 = len(item2) self.assertEquals(l1, l2, "Size of data 1 at level {} != size of data 2".format(step)) for next_idx in range(len(item1[index])): new_indicies = prev_indicies[:] new_indicies.append(next_idx) compare(new_indicies, item1[index], item2[index]) for idx in range(len(data1)): compare([idx], data1, data2)
def convert(cls, socket, source_data): if is_matrix_to_vfield(socket): return matrices_to_vfield(source_data) elif is_vertex_to_vfield(socket): return vertices_to_vfield(source_data) elif is_string_to_sfield(socket): level = get_data_nesting_level(source_data) if level > 2: raise TypeError("Too high data nesting level for Number -> Scalar Field conversion: %s" % level) return numbers_to_sfield(source_data) else: super().convert(socket, source_data)
def process(self): if not any(socket.is_linked for socket in self.outputs): return solid_in = self.inputs['Solid'].sv_get() sites_in = self.inputs['Sites'].sv_get() iterations_in = self.inputs['Iterations'].sv_get() thickness_in = self.inputs['Thickness'].sv_get() weights_in = self.inputs['Weights'].sv_get(default=[[None]]) solid_in = ensure_nesting_level(solid_in, 2, data_types=(Part.Shape, )) input_level = get_data_nesting_level(sites_in) sites_in = ensure_nesting_level(sites_in, 4) iterations_in = ensure_nesting_level(iterations_in, 2) thickness_in = ensure_nesting_level(thickness_in, 2) if self.inputs['Weights'].is_linked: weights_in = ensure_nesting_level(weights_in, 2, data_types=(SvScalarField, )) nested_output = input_level > 3 tolerance = 10**(-self.accuracy) verts_out = [] for params in zip_long_repeat(solid_in, sites_in, iterations_in, thickness_in, weights_in): new_verts = [] for solid, sites, iterations, thickness, weights in zip_long_repeat( *params): if self.mode == 'VOLUME': sites = lloyd_in_solid(solid, sites, iterations, weight_field=weights, tolerance=tolerance) else: sites = lloyd_on_solid_surface(solid, sites, thickness, iterations, weight_field=weights, tolerance=tolerance) new_verts.append(sites) if nested_output: verts_out.append(new_verts) else: verts_out.extend(new_verts) self.outputs['Sites'].sv_set(verts_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return profile_s = self.inputs['Profile'].sv_get() taper_s = self.inputs['Taper'].sv_get() point_s = self.inputs['Point'].sv_get() direction_s = self.inputs['Direction'].sv_get() input_level = get_data_nesting_level(profile_s, data_types=(SvCurve, )) profile_s = ensure_nesting_level(profile_s, 2, data_types=(SvCurve, )) taper_s = ensure_nesting_level(taper_s, 2, data_types=(SvCurve, )) point_s = ensure_nesting_level(point_s, 3) direction_s = ensure_nesting_level(direction_s, 3) def check_nurbs(*curves): return [SvNurbsCurve.to_nurbs(c) for c in curves] surface_out = [] for params in zip_long_repeat(profile_s, taper_s, point_s, direction_s): new_surfaces = [] for profile, taper, point, direction in zip_long_repeat(*params): if self.use_nurbs: profile_nurbs, taper_nurbs = check_nurbs(profile, taper) if profile_nurbs is None: raise Exception("One of profiles is not NURBS") if taper_nurbs is None: raise Exception("One of tapers is not NURBS") surface = nurbs_taper_sweep(profile_nurbs, taper_nurbs, np.array(point), np.array(direction), scale_base=self.scale_mode) else: surface = SvTaperSweepSurface(profile, taper, np.array(point), np.array(direction), scale_base=self.scale_mode) new_surfaces.append(surface) if input_level < 2: surface_out.extend(new_surfaces) else: surface_out.append(new_surfaces) self.outputs['Surface'].sv_set(surface_out)
def test_fuse_4(self): "Input level 2, Merge = Off" box1 = self._make_box_node(0, 0, 0, size=2) box2 = self._make_box_node(1, 1, 1, size=2) join = self._make_list_join() join.JoinLevel = 2 self.tree.links.new(box1.outputs[0], join.inputs[0]) self.tree.links.new(box2.outputs[0], join.inputs[1]) self.tree.links.new(join.outputs[0], self.node.inputs["Solids"]) self.node.merge_result = False self.node.process() out = self.get_output_data("Solid") out_level = get_data_nesting_level(out, data_types=(Part.Shape, )) self.assertEquals(out_level, 2) #out_len = len(out) #self.assertEquals(out_len, 1) map = self.get_output_data("SolidSources") self.assert_sverchok_data_equal(map, [[[0], [0, 1], [1]]]) mask = self.get_output_data("EdgesMask") mask_level = get_data_nesting_level(mask) self.assertEqual(mask_level, 3) map = self.get_output_data("EdgeSources") map_level = get_data_nesting_level(map) self.assertEqual(map_level, 4) mask = self.get_output_data("FacesMask") mask_level = get_data_nesting_level(mask) self.assertEqual(mask_level, 3) map = self.get_output_data("FaceSources") map_level = get_data_nesting_level(map) self.assertEqual(map_level, 4)
def convert(cls, socket, other, source_data): # let policy to decide if deep copy of data is needed if test_socket_type(socket, other, 'm', 'vf'): return matrices_to_vfield(source_data) if test_socket_type(socket, other, 'v', 'vf'): return vertices_to_vfield(source_data) if test_socket_type(socket, other, 's', 'sf'): level = get_data_nesting_level(source_data) if level > 2: raise TypeError("Too high data nesting level for Number -> Scalar Field conversion: %s" % level) return numbers_to_sfield(source_data) return super().convert(socket, other, source_data)
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() degree_s = self.inputs['Degree'].sv_get() points_cnt_s = self.inputs['PointsCnt'].sv_get() input_level = get_data_nesting_level(vertices_s) vertices_s = ensure_nesting_level(vertices_s, 4) degree_s = ensure_nesting_level(degree_s, 2) points_cnt_s = ensure_nesting_level(points_cnt_s, 2) nested_output = input_level > 3 curves_out = [] points_out = [] knots_out = [] for params in zip_long_repeat(vertices_s, degree_s, points_cnt_s): new_curves = [] new_points = [] new_knots = [] for vertices, degree, points_cnt in zip_long_repeat(*params): kwargs = dict(centripetal=self.centripetal) if self.has_points_cnt: kwargs['ctrlpts_size'] = points_cnt curve = fitting.approximate_curve(vertices, degree, **kwargs) new_points.append(curve.ctrlpts) new_knots.append(curve.knotvector) curve = SvGeomdlCurve(curve) new_curves.append(curve) if nested_output: curves_out.append(new_curves) points_out.append(new_points) knots_out.append(new_knots) else: curves_out.extend(new_curves) points_out.extend(new_points) knots_out.extend(new_knots) self.outputs['Curve'].sv_set(curves_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['Knots'].sv_set(knots_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() edges_s = self.inputs['Edges'].sv_get() faces_s = self.inputs['Faces'].sv_get() epsilon_s = self.inputs['Epsilon'].sv_get() smooth_s = self.inputs['Smooth'].sv_get() scale_s = self.inputs['Scale'].sv_get() input_level = get_data_nesting_level(vertices_s) vertices_s = ensure_nesting_level(vertices_s, 4) edges_s = ensure_nesting_level(edges_s, 4) faces_s = ensure_nesting_level(faces_s, 4) epsilon_s = ensure_nesting_level(epsilon_s, 2) smooth_s = ensure_nesting_level(smooth_s, 2) scale_s = ensure_nesting_level(scale_s, 2) nested_output = input_level > 3 fields_out = [] for params in zip_long_repeat(vertices_s, edges_s, faces_s, epsilon_s, smooth_s, scale_s): new_fields = [] for vertices, edges, faces, epsilon, smooth, scale in zip_long_repeat( *params): bm = bmesh_from_pydata(vertices, edges, faces, normal_update=True) field = mesh_field(bm, self.function, smooth, epsilon, scale, use_verts=self.use_verts, use_edges=self.use_edges, use_faces=self.use_faces) new_fields.append(field) if nested_output: fields_out.append(new_fields) else: fields_out.extend(new_fields) self.outputs['Field'].sv_set(fields_out)
def make_lamp(self, index, object): origin, size, size_x, size_y, strength, spot_size, spot_blend, color = object if get_data_nesting_level(color) == 2: color = color[0] if isinstance(size, (list, tuple)): size = size[0] if isinstance(size_x, (list, tuple)): size_x = size_x[0] if isinstance(size_y, (list, tuple)): size_y = size_y[0] if isinstance(strength, (list, tuple)): strength = strength[0] if isinstance(spot_size, (list, tuple)): spot_size = spot_size[0] if isinstance(spot_blend, (list, tuple)): spot_blend = spot_blend[0] scene = bpy.context.scene lamps_data = bpy.data.lamps objects = bpy.data.objects name = self.lamp_name + "_" + str(index) if name in objects: lamp_object = objects[name] if lamp_object.data.type != self.type: lamp_object.data.type = self.type else: lamp_data = lamps_data.new(name = name, type = self.type) lamp_object = objects.new(name = name, object_data = lamp_data) scene.objects.link(lamp_object) lamp_object['idx'] = index lamp_object['madeby'] = self.name lamp_object['basename'] = self.lamp_name lamp_object.matrix_local = origin lamp = lamp_object.data lamp.type = self.type lamp.color = color[:3] if self.type in ('POINT', 'SUN', 'SPOT'): lamp.shadow_soft_size = size elif self.type == 'AREA' and self.area_type == 'SQUARE': lamp.shape = 'SQUARE' lamp.size = size elif self.type == 'AREA' and self.area_type == 'RECTANGLE': lamp.shape = 'RECTANGLE' lamp.size = size_x lamp.size_y = size_y if self.type == 'SPOT': lamp.spot_size = radians(spot_size) lamp.spot_blend = spot_blend lamp.show_cone = self.show_cone if lamp.cycles: lamp.cycles.max_bounces = self.max_bounces lamp.cycles.cast_shadow = self.cast_shadow lamp.cycles.use_multiple_importance_sampling = self.multiple_imporance lamp.use_nodes = True if self.emission_node_name and self.emission_node_name in lamp.node_tree.nodes: node = lamp.node_tree.nodes[self.emission_node_name] node.inputs['Strength'].default_value = strength if len(color) != 4: raise Exception("Color data must contain 4 floats (RGBA), not {}".format(len(color))) node.inputs['Color'].default_value = color