def sv_get_socket(socket, deepcopy=True):
"""gets socket data from socket,
if deep copy is True a deep copy is make_dep_dict,
to increase performance if the node doesn't mutate input
set to False and increase performance substanstilly
"""
data = socket_data_cache.get(socket.socket_id)
if data is not None:
return sv_deep_copy(data) if deepcopy else data
else:
raise SvNoDataError(socket)
def get_output_socket_data(node, output_socket_name):
"""
This method is intended to usage in internal tests mainly.
Get data that the node has written to the output socket.
Raises SvNoDataError if it hasn't written any.
"""
socket = node.outputs[output_socket_name]
sock_address = socket.socket_id
if sock_address in socket_data_cache:
return socket_data_cache[sock_address]
else:
raise SvNoDataError(socket)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if self.proportional and not self.inputs['Field'].is_linked:
raise SvNoDataError(socket=self.inputs['Field'], node=self)
solid_s = self.inputs['Solid'].sv_get()
fields_s = self.inputs['Field'].sv_get(default=[[None]])
count_s = self.inputs['Count'].sv_get()
min_r_s = self.inputs['MinDistance'].sv_get()
threshold_s = self.inputs['Threshold'].sv_get()
field_min_s = self.inputs['FieldMin'].sv_get()
field_max_s = self.inputs['FieldMax'].sv_get()
mask_s = self.inputs['FaceMask'].sv_get(default=[[[True]]])
seed_s = self.inputs['Seed'].sv_get()
solid_s = ensure_nesting_level(solid_s, 2, data_types=(Part.Shape, ))
if self.inputs['Field'].is_linked:
fields_s = ensure_nesting_level(fields_s,
2,
data_types=(SvScalarField, ))
count_s = ensure_nesting_level(count_s, 2)
min_r_s = ensure_nesting_level(min_r_s, 2)
threshold_s = ensure_nesting_level(threshold_s, 2)
field_min_s = ensure_nesting_level(field_min_s, 2)
field_max_s = ensure_nesting_level(field_max_s, 2)
mask_s = ensure_nesting_level(mask_s, 3)
seed_s = ensure_nesting_level(seed_s, 2)
verts_out = []
inputs = zip_long_repeat(solid_s, fields_s, count_s, min_r_s,
threshold_s, field_min_s, field_max_s, mask_s,
seed_s)
for objects in inputs:
for solid, field, count, min_r, threshold, field_min, field_max, mask, seed in zip_long_repeat(
*objects):
if self.gen_mode == 'VOLUME':
new_verts = self.generate_volume(solid, field, count,
min_r, threshold,
field_min, field_max,
seed)
else:
new_verts = self.generate_surface(solid, field, count,
min_r, threshold,
field_min, field_max,
mask, seed)
verts_out.append(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()
offset_s = self.inputs['Offset'].sv_get()
offset_curve_s = self.inputs['OffsetCurve'].sv_get(default = [[None]])
vector_s = self.inputs['Vector'].sv_get()
resolution_s = self.inputs['Resolution'].sv_get()
curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve,))
offset_s = ensure_nesting_level(offset_s, 2)
vector_s = ensure_nesting_level(vector_s, 3)
resolution_s = ensure_nesting_level(resolution_s, 2)
if self.inputs['OffsetCurve'].is_linked:
offset_curve_s = ensure_nesting_level(offset_curve_s, 2, data_types=(SvCurve,))
curve_out = []
for curves, offsets, offset_curves, vectors, resolutions in zip_long_repeat(curve_s, offset_s, offset_curve_s, vector_s, resolution_s):
new_curves = []
for curve, offset, offset_curve, vector, resolution in zip_long_repeat(curves, offsets, offset_curves, vectors, resolutions):
if self.algorithm != NORMAL_DIR:
if self.mode == 'X':
vector = [offset, 0, 0]
elif self.mode == 'Y':
vector = [0, offset, 0]
if vector is not None:
vector = np.array(vector)
if self.offset_type == 'CONST':
new_curve = SvOffsetCurve(curve,
offset_vector = vector,
offset_amount = offset,
algorithm = self.algorithm,
resolution = resolution)
else:
if offset_curve is None:
raise SvNoDataError(socket=self.inputs['OffsetCurve'], node=self)
new_curve = SvOffsetCurve(curve,
offset_vector = vector,
offset_curve = offset_curve,
algorithm = self.algorithm,
resolution = resolution)
new_curves.append(new_curve)
curve_out.append(new_curves)
self.outputs['Curve'].sv_set(curve_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
curve_s = self.inputs['Curve'].sv_get()
surface_s = self.inputs['Surface'].sv_get()
offset_s = self.inputs['Offset'].sv_get()
offset_curve_s = self.inputs['OffsetCurve'].sv_get(default = [[None]])
curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve,))
surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface,))
offset_s = ensure_nesting_level(offset_s, 2)
if self.inputs['OffsetCurve'].is_linked:
offset_curve_s = ensure_nesting_level(offset_curve_s, 2, data_types=(SvCurve,))
curves_out = []
uv_curves_out = []
for curves, surfaces, offsets, offset_curves in zip_long_repeat(curve_s, surface_s, offset_s, offset_curve_s):
new_curves = []
new_uv_curves = []
for curve, surface, offset, offset_curve in zip_long_repeat(curves, surfaces, offsets, offset_curves):
if self.offset_type == 'CONST':
new_curve = SvCurveOffsetOnSurface(curve, surface, offset=offset,
uv_space=False, axis=self.curve_axis)
new_uv_curve = SvCurveOffsetOnSurface(curve, surface, offset=offset,
uv_space=True, axis=self.curve_axis)
else:
if offset_curve is None:
raise SvNoDataError(socket=self.inputs['OffsetCurve'], node=self)
new_curve = SvCurveOffsetOnSurface(curve, surface,
offset_curve = offset_curve,
offset_curve_type = self.offset_curve_type,
len_resolution = self.len_resolution,
uv_space = False, axis = self.curve_axis)
new_uv_curve = SvCurveOffsetOnSurface(curve, surface,
offset_curve = offset_curve,
offset_curve_type = self.offset_curve_type,
len_resolution = self.len_resolution,
uv_space = True, axis = self.curve_axis)
new_curves.append(new_curve)
new_uv_curves.append(new_uv_curve)
curves_out.append(new_curves)
uv_curves_out.append(new_uv_curves)
self.outputs['Curve'].sv_set(curves_out)
self.outputs['UVCurve'].sv_set(uv_curves_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if self.proportional and not self.inputs['Field'].is_linked:
raise SvNoDataError(socket=self.inputs['Field'], node=self)
surface_s = self.inputs['Surface'].sv_get()
fields_s = self.inputs['Field'].sv_get(default=[[None]])
count_s = self.inputs['Count'].sv_get()
threshold_s = self.inputs['Threshold'].sv_get()
field_min_s = self.inputs['FieldMin'].sv_get()
field_max_s = self.inputs['FieldMax'].sv_get()
min_r_s = self.inputs['MinDistance'].sv_get()
seed_s = self.inputs['Seed'].sv_get()
surface_s = ensure_nesting_level(surface_s,
2,
data_types=(SvSurface, ))
has_field = self.inputs['Field'].is_linked
if has_field:
fields_s = ensure_nesting_level(fields_s,
2,
data_types=(SvScalarField, ))
verts_out = []
uv_out = []
parameters = zip_long_repeat(surface_s, fields_s, count_s, threshold_s,
field_min_s, field_max_s, min_r_s, seed_s)
for surfaces, fields, counts, thresholds, field_mins, field_maxs, min_rs, seeds in parameters:
objects = zip_long_repeat(surfaces, fields, counts, thresholds,
field_mins, field_maxs, min_rs, seeds)
for surface, field, count, threshold, field_min, field_max, min_r, seed in objects:
new_uv, new_verts = populate_surface(surface, field, count,
threshold,
self.proportional,
field_min, field_max,
min_r, seed)
verts_out.append(new_verts)
uv_out.append(new_uv)
self.outputs['Vertices'].sv_set(verts_out)
self.outputs['UVPoints'].sv_set(uv_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if self.proportional and not self.inputs['Field'].is_linked:
raise SvNoDataError(socket=self.inputs['Field'], node=self)
fields_s = self.inputs['Field'].sv_get(default=[[None]])
vertices_s = self.inputs['Bounds'].sv_get()
count_s = self.inputs['Count'].sv_get()
min_r_s = self.inputs['MinDistance'].sv_get()
threshold_s = self.inputs['Threshold'].sv_get()
field_min_s = self.inputs['FieldMin'].sv_get()
field_max_s = self.inputs['FieldMax'].sv_get()
seed_s = self.inputs['Seed'].sv_get()
if self.inputs['Field'].is_linked:
fields_s = ensure_nesting_level(fields_s,
2,
data_types=(SvScalarField, ))
vertices_s = ensure_nesting_level(vertices_s, 4)
count_s = ensure_nesting_level(count_s, 2)
min_r_s = ensure_nesting_level(min_r_s, 2)
threshold_s = ensure_nesting_level(threshold_s, 2)
field_min_s = ensure_nesting_level(field_min_s, 2)
field_max_s = ensure_nesting_level(field_max_s, 2)
seed_s = ensure_nesting_level(seed_s, 2)
verts_out = []
inputs = zip_long_repeat(fields_s, vertices_s, threshold_s,
field_min_s, field_max_s, count_s, min_r_s,
seed_s)
for objects in inputs:
for field, vertices, threshold, field_min, field_max, count, min_r, seed in zip_long_repeat(
*objects):
bbox = self.get_bounds(vertices)
new_verts = field_random_probe(field, bbox, count, threshold,
self.proportional, field_min,
field_max, min_r, seed)
verts_out.append(new_verts)
self.outputs['Vertices'].sv_set(verts_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
start_s = self.inputs['Start'].sv_get()
end_s = self.inputs['End'].sv_get()
knot1_s = self.inputs[CONTROL1_SOCKET].sv_get()
knot2_s = self.inputs[CONTROL2_SOCKET].sv_get()
controls_s = self.inputs['ControlPoints'].sv_get(default=[[[[]]]])
start_s = ensure_nesting_level(start_s, 3)
end_s = ensure_nesting_level(end_s, 3)
knot1_s = ensure_nesting_level(knot1_s, 3)
knot2_s = ensure_nesting_level(knot2_s, 3)
controls_s = ensure_nesting_level(controls_s, 4)
curves_out = []
controls_out = []
for starts, ends, knot1s, knot2s, controls_i in zip_long_repeat(
start_s, end_s, knot1_s, knot2_s, controls_s):
new_curves = []
new_controls = []
for start, end, knot1, knot2, controls in zip_long_repeat(
starts, ends, knot1s, knot2s, controls_i):
start, end = np.array(start), np.array(end)
knot1, knot2 = np.array(knot1), np.array(knot2)
if self.mode == CUBIC:
curve = SvCubicBezierCurve(start, knot1, knot2, end)
curve_controls = [
start.tolist(),
knot1.tolist(),
knot2.tolist(),
end.tolist()
]
elif self.mode == CUBIC_TANGENT:
curve = SvBezierCurve.from_points_and_tangents(
start, knot1, knot2, end)
curve_controls = [
curve.p0.tolist(),
curve.p1.tolist(),
curve.p2.tolist(),
curve.p3.tolist()
]
elif self.mode == CUBIC_4PT:
curve = SvCubicBezierCurve.from_four_points(
start, knot1, knot2, end)
curve_controls = [
curve.p0.tolist(),
curve.p1.tolist(),
curve.p2.tolist(),
curve.p3.tolist()
]
elif self.mode == QUADRATIC:
curve = SvBezierCurve([start, knot1, end])
curve_controls = [p.tolist() for p in curve.points]
else: # GENERIC
if not controls:
raise SvNoDataError(
socket=self.inputs['ControlPoints'], node=self)
if len(controls) < 2:
raise Exception(
"At least two control points are required to build a Bezier spline!"
)
if self.is_cyclic:
controls = controls + [controls[0]]
curve = SvBezierCurve(controls)
curve_controls = controls
new_curves.append(curve)
new_controls.extend(curve_controls)
curves_out.append(new_curves)
controls_out.append(new_controls)
self.outputs['Curve'].sv_set(curves_out)
self.outputs['ControlPoints'].sv_set(controls_out)
def process(self):
# upgrades older versions of ProfileMK3 to the version that has self.file_pointer
if self.filename and not self.file_pointer:
text = self.get_bpy_data_from_name(self.filename, bpy.data.texts)
if text:
self.file_pointer = text
if not any(o.is_linked for o in self.outputs):
return
sync_pointer_and_stored_name(self, "file_pointer", "filename")
profile = self.load_profile()
optional_inputs = self.get_optional_inputs(profile)
var_names = self.get_variables()
self.debug("Var_names: %s; optional: %s", var_names, optional_inputs)
inputs = self.get_input()
result_vertices = []
result_edges = []
result_knots = []
result_names = []
result_curves = []
if var_names:
input_values = []
for name in var_names:
try:
input_values.append(inputs[name])
except KeyError as e:
name = e.args[0]
if name not in optional_inputs:
if name in self.inputs:
raise SvNoDataError(self.inputs[name])
else:
self.adjust_sockets()
raise SvNoDataError(self.inputs[name])
else:
input_values.append([None])
parameters = match_long_repeat(input_values)
else:
parameters = [[[]]]
input_names = [
socket.name for socket in self.inputs if socket.is_linked
]
for values in zip(*parameters):
variables = dict(zip(var_names, values))
curves_form = Interpreter.NURBS if self.nurbs_out else None
interpreter = Interpreter(self,
input_names,
curves_form=curves_form,
z_axis=self.selected_axis)
interpreter.interpret(profile, variables)
verts = self.extend_out_verts(interpreter.vertices)
result_vertices.append(verts)
result_edges.append(interpreter.edges)
knots = self.extend_out_verts(interpreter.knots)
result_knots.append(knots)
result_names.append([[name] for name in interpreter.knotnames])
all_curves = interpreter.curves
if self.concat_curves:
new_curves = []
for curves in self.group_curves(all_curves):
if self.nurbs_out:
curves = unify_curves_degree(curves)
curve = concatenate_curves(curves)
new_curves.append(curve)
result_curves.append(new_curves)
else:
result_curves.append(all_curves)
self.outputs['Vertices'].sv_set(result_vertices)
self.outputs['Edges'].sv_set(result_edges)
self.outputs['Knots'].sv_set(result_knots)
self.outputs['KnotNames'].sv_set(result_names)
if 'Curve' in self.outputs:
self.outputs['Curve'].sv_set(result_curves)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if self.proportional and not self.inputs['Field'].is_linked:
raise SvNoDataError(socket=self.inputs['Field'], node=self)
fields_s = self.inputs['Field'].sv_get(default=[[None]])
if self.distance_mode == 'FIELD':
radius_s = self.inputs['RadiusField'].sv_get()
else:
radius_s = [[None]]
vertices_s = self.inputs['Bounds'].sv_get()
count_s = self.inputs['Count'].sv_get()
min_r_s = self.inputs['MinDistance'].sv_get()
threshold_s = self.inputs['Threshold'].sv_get()
field_min_s = self.inputs['FieldMin'].sv_get()
field_max_s = self.inputs['FieldMax'].sv_get()
seed_s = self.inputs['Seed'].sv_get()
if self.inputs['Field'].is_linked:
fields_s = ensure_nesting_level(fields_s,
2,
data_types=(SvScalarField, ))
input_level = get_data_nesting_level(fields_s,
data_types=(SvScalarField, ))
nested_field = input_level > 1
else:
nested_field = False
if self.inputs['RadiusField'].is_linked:
radius_s = ensure_nesting_level(radius_s,
2,
data_types=(SvScalarField, ))
input_level = get_data_nesting_level(radius_s,
data_types=(SvScalarField, ))
nested_radius = input_level > 1
else:
nested_radius = False
verts_level = get_data_nesting_level(vertices_s)
nested_verts = verts_level > 3
vertices_s = ensure_nesting_level(vertices_s, 4)
count_s = ensure_nesting_level(count_s, 2)
min_r_s = ensure_nesting_level(min_r_s, 2)
threshold_s = ensure_nesting_level(threshold_s, 2)
field_min_s = ensure_nesting_level(field_min_s, 2)
field_max_s = ensure_nesting_level(field_max_s, 2)
seed_s = ensure_nesting_level(seed_s, 2)
nested_output = nested_field or nested_radius or nested_verts
verts_out = []
radius_out = []
inputs = zip_long_repeat(fields_s, radius_s, vertices_s, threshold_s,
field_min_s, field_max_s, count_s, min_r_s,
seed_s)
for objects in inputs:
new_verts = []
new_radiuses = []
for field, radius_field, vertices, threshold, field_min, field_max, count, min_r, seed in zip_long_repeat(
*objects):
bbox = self.get_bounds(vertices)
if self.distance_mode == 'FIELD':
min_r = 0
verts, radiuses = field_random_probe(
field,
bbox,
count,
threshold,
self.proportional,
field_min,
field_max,
min_r=min_r,
min_r_field=radius_field,
random_radius=self.random_radius,
seed=seed)
if self.flat_output:
new_verts.extend(verts)
new_radiuses.extend(radiuses)
else:
new_verts.append(verts)
new_radiuses.append(radiuses)
if nested_output:
verts_out.append(new_verts)
radius_out.append(new_radiuses)
else:
verts_out.extend(new_verts)
radius_out.extend(new_radiuses)
self.outputs['Vertices'].sv_set(verts_out)
self.outputs['Radius'].sv_set(radius_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if self.proportional and not self.inputs['Field'].is_linked:
raise SvNoDataError(socket=self.inputs['Field'], node=self)
surface_s = self.inputs['Surface'].sv_get()
fields_s = self.inputs['Field'].sv_get(default=[[None]])
count_s = self.inputs['Count'].sv_get()
threshold_s = self.inputs['Threshold'].sv_get()
field_min_s = self.inputs['FieldMin'].sv_get()
field_max_s = self.inputs['FieldMax'].sv_get()
min_r_s = self.inputs['MinDistance'].sv_get()
if self.distance_mode == 'FIELD':
radius_s = self.inputs['RadiusField'].sv_get()
else:
radius_s = [[None]]
seed_s = self.inputs['Seed'].sv_get()
input_level = get_data_nesting_level(surface_s,
data_types=(SvSurface, ))
nested_surface = input_level > 1
surface_s = ensure_nesting_level(surface_s,
2,
data_types=(SvSurface, ))
has_field = self.inputs['Field'].is_linked
if has_field:
input_level = get_data_nesting_level(fields_s,
data_types=(SvScalarField, ))
nested_field = input_level > 1
fields_s = ensure_nesting_level(fields_s,
2,
data_types=(SvScalarField, ))
else:
nested_field = False
if self.distance_mode == 'FIELD':
input_level = get_data_nesting_level(radius_s,
data_types=(SvScalarField, ))
nested_radius = input_level > 1
radius_s = ensure_nesting_level(radius_s,
2,
data_types=(SvScalarField, ))
else:
nested_radius = False
nested_output = nested_surface or nested_field or nested_radius
verts_out = []
uv_out = []
radius_out = []
inputs = zip_long_repeat(surface_s, fields_s, radius_s, count_s,
threshold_s, field_min_s, field_max_s,
min_r_s, seed_s)
for params in inputs:
new_uv = []
new_verts = []
new_radius = []
for surface, field, radius, count, threshold, field_min, field_max, min_r, seed in zip_long_repeat(
*params):
if self.distance_mode == 'FIELD':
min_r = 0
uvs, verts, radiuses = populate_surface(
surface,
field,
count,
threshold,
self.proportional,
field_min,
field_max,
min_r=min_r,
min_r_field=radius,
random_radius=self.random_radius,
seed=seed)
new_verts.append(verts)
new_uv.append(uvs)
new_radius.append(radiuses)
if nested_output:
verts_out.append(new_verts)
uv_out.append(new_uv)
radius_out.append(new_radius)
else:
verts_out.extend(new_verts)
uv_out.extend(new_uv)
radius_out.extend(new_radius)
self.outputs['Vertices'].sv_set(verts_out)
self.outputs['UVPoints'].sv_set(uv_out)
self.outputs['Radiuses'].sv_set(radius_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
if self.proportional and not self.inputs['Field'].is_linked:
raise SvNoDataError(socket=self.inputs['Field'], node=self)
solid_s = self.inputs['Solid'].sv_get()
fields_s = self.inputs['Field'].sv_get(default=[[None]])
count_s = self.inputs['Count'].sv_get()
min_r_s = self.inputs['MinDistance'].sv_get()
threshold_s = self.inputs['Threshold'].sv_get()
field_min_s = self.inputs['FieldMin'].sv_get()
field_max_s = self.inputs['FieldMax'].sv_get()
mask_s = self.inputs['FaceMask'].sv_get(default=[[[True]]])
seed_s = self.inputs['Seed'].sv_get()
if self.distance_mode == 'FIELD':
radius_s = self.inputs['RadiusField'].sv_get()
else:
radius_s = [[None]]
input_level = get_data_nesting_level(solid_s,
data_types=(Part.Shape, ))
nested_solid = input_level > 1
solid_s = ensure_nesting_level(solid_s, 2, data_types=(Part.Shape, ))
if self.inputs['Field'].is_linked:
input_level = get_data_nesting_level(fields_s,
data_types=(SvScalarField, ))
nested_field = input_level > 1
fields_s = ensure_nesting_level(fields_s,
2,
data_types=(SvScalarField, ))
else:
nested_field = False
if self.distance_mode == 'FIELD':
input_level = get_data_nesting_level(radius_s,
data_types=(SvScalarField, ))
nested_radius = input_level > 1
radius_s = ensure_nesting_level(radius_s,
2,
data_types=(SvScalarField, ))
else:
nested_radius = False
count_s = ensure_nesting_level(count_s, 2)
min_r_s = ensure_nesting_level(min_r_s, 2)
threshold_s = ensure_nesting_level(threshold_s, 2)
field_min_s = ensure_nesting_level(field_min_s, 2)
field_max_s = ensure_nesting_level(field_max_s, 2)
mask_s = ensure_nesting_level(mask_s, 3)
seed_s = ensure_nesting_level(seed_s, 2)
nested_output = nested_solid or nested_field or nested_radius
verts_out = []
radius_out = []
inputs = zip_long_repeat(solid_s, fields_s, count_s, min_r_s, radius_s,
threshold_s, field_min_s, field_max_s, mask_s,
seed_s)
for objects in inputs:
new_verts = []
new_radius = []
for solid, field, count, min_r, radius, threshold, field_min, field_max, mask, seed in zip_long_repeat(
*objects):
if seed == 0:
seed = 12345
random.seed(seed)
if self.distance_mode == 'FIELD':
min_r = 0
if self.gen_mode == 'VOLUME':
verts, radiuses = self.generate_volume(
solid, field, count, min_r, radius, threshold,
field_min, field_max)
else:
verts, radiuses = self.generate_surface(
solid, field, count, min_r, radius, threshold,
field_min, field_max, mask)
new_verts.append(verts)
new_radius.append(radiuses)
if nested_output:
verts_out.append(new_verts)
radius_out.append(new_radius)
else:
verts_out.extend(new_verts)
radius_out.extend(new_radius)
self.outputs['Vertices'].sv_set(verts_out)
self.outputs['Radiuses'].sv_set(radius_out)