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
