def process(self):
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))
interpreter = Interpreter(self, input_names)
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])
result_curves.append(interpreter.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 sv_get(self, default=sentinel, deepcopy=True, implicit_conversions=None):
if self.is_linked and not self.is_output:
return self.convert_data(SvGetSocket(self, deepcopy), implicit_conversions)
elif self.object_ref:
obj_ref = bpy.data.objects.get(self.object_ref.strip())
if not obj_ref:
raise SvNoDataError(self)
return [obj_ref]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True):
if self.is_linked and not self.is_output:
return SvGetSocket(self, deepcopy)
elif self.object_ref:
obj_ref = bpy.data.objects.get(self.object_ref)
if not obj_ref:
raise SvNoDataError(self)
return [obj_ref]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True, implicit_conversions=None):
if self.is_linked and not self.is_output:
return self.convert_data(SvGetSocket(self, deepcopy), implicit_conversions)
elif self.object_ref or self.object_ref_pointer:
# this can be more granular and even attempt to set object_ref_points from object_ref, and then wipe object_ref
obj_ref = self.node.get_bpy_data_from_name(self.object_ref or self.object_ref_pointer, bpy.data.objects)
if not obj_ref:
raise SvNoDataError(self)
return [obj_ref]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self,
default=sentinel,
deepcopy=True,
implicit_conversions=None):
# debug("Node %s, socket %s, is_linked: %s, is_output: %s",
# self.node.name, self.name, self.is_linked, self.is_output)
if self.is_linked and not self.is_output:
return self.convert_data(SvGetSocket(self, deepcopy),
implicit_conversions)
elif self.get_prop_name():
# to deal with subtype ANGLE, this solution should be considered temporary...
_, prop_dict = getattr(self.node.rna_type, self.get_prop_name(),
(None, {}))
subtype = prop_dict.get("subtype", "")
if subtype == "ANGLE":
return [[
math.degrees(getattr(self.node, self.get_prop_name()))
]]
return [[getattr(self.node, self.get_prop_name())]]
elif self.prop_type:
return [[getattr(self.node, self.prop_type)[self.prop_index]]]
elif default is not sentinel:
return default
else:
raise SvNoDataError(self)
def sv_get(self, default=sentinel, deepcopy=True):
if self.is_linked and not self.is_output:
return SvGetSocket(self, deepcopy)
elif self.text:
return [self.text]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True, implicit_conversions=None):
if self.is_linked and not self.is_output:
return self.convert_data(SvGetSocket(self, deepcopy), implicit_conversions)
elif self.text:
return [self.text]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True, implicit_conversions=None):
self.num_matrices = 0
if self.is_linked and not self.is_output:
source_data = SvGetSocket(self, deepcopy = True if self.needs_data_conversion() else deepcopy)
return self.convert_data(source_data, implicit_conversions)
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True):
if self.is_linked and not self.is_output:
return SvGetSocket(self, deepcopy=True if self.needs_data_conversion() else deepcopy)
if self.get_prop_name():
return [[getattr(self.node, self.get_prop_name())[:]]]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self,
default=sentinel,
deepcopy=True,
implicit_conversions=None):
"""
The method is used for getting input socket data
In most cases the method should not be overridden
If socket uses custom implicit_conversion it should implements default_conversion_name attribute
Also a socket can use its default_property
Order of getting data (if available):
1. writen socket data
2. node default property
3. socket default property
4. script default property
5. Raise no data error
:param default: script default property
:param deepcopy: in most cases should be False for efficiency but not in cases if input data will be modified
:param implicit_conversions: if needed automatic conversion data from one socket type to another
:return: data bound to the socket
"""
if implicit_conversions is None:
if hasattr(self, 'default_conversion_name'):
implicit_conversions = ConversionPolicies.get_conversion(
self.default_conversion_name)
else:
implicit_conversions = ConversionPolicies.DEFAULT.conversion
if self.is_linked and not self.is_output:
return self.convert_data(SvGetSocket(self, deepcopy),
implicit_conversions)
elif self.get_prop_name():
prop = getattr(self.node, self.get_prop_name())
if isinstance(prop, (str, int, float)):
return [[prop]]
elif hasattr(prop, '__len__'):
# it looks like as some BLender property array - convert to tuple
return [[prop[:]]]
else:
return [prop]
elif self.use_prop and hasattr(
self,
'default_property') and self.default_property is not None:
default_property = self.default_property
if isinstance(default_property, (str, int, float)):
return [[default_property]]
elif hasattr(default_property, '__len__'):
# it looks like as some BLender property array - convert to tuple
return [[default_property[:]]]
else:
return [default_property]
elif default is not sentinel:
return default
else:
raise SvNoDataError(self)
def sv_get(self, default=sentinel, deepcopy=True, implicit_conversions=None):
if self.is_linked and not self.is_output:
source_data = SvGetSocket(self, deepcopy=True if self.needs_data_conversion() else deepcopy)
return self.convert_data(source_data, implicit_conversions)
if self.prop_name:
return [[getattr(self.node, self.prop_name)[:]]]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
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 sv_get(self, default=sentinel, deepcopy=True):
if self.is_linked and not self.is_output:
return SvGetSocket(self, deepcopy)
if self.prop_name:
return [[getattr(self.node, self.prop_name)[:]]]
elif self.use_prop:
return [[self.prop[:]]]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True, implicit_conversions=None):
if self.is_linked and not self.is_output:
return self.convert_data(SvGetSocket(self, deepcopy), implicit_conversions)
if self.get_prop_name():
return [[getattr(self.node, self.get_prop_name())[:]]]
elif self.use_prop:
return [[self.prop[:]]]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
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 sv_get(self, default=sentinel, deepcopy=True):
if self.is_linked and not self.is_output:
if is_matrix_to_vector(self):
out = get_locs_from_matrices(SvGetSocket(self, deepcopy=True))
return out
return SvGetSocket(self, deepcopy)
if self.prop_name:
return [[getattr(self.node, self.prop_name)[:]]]
elif self.use_prop:
return [[self.prop[:]]]
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
def sv_get(self, default=sentinel, deepcopy=True):
if self.is_linked and not self.is_output:
return SvGetSocket(self, deepcopy)
elif self.prop_name:
# to deal with subtype ANGLE, this solution should be considered temporary...
_, prop_dict = getattr(self.node.rna_type, self.prop_name, (None, {}))
subtype = prop_dict.get("subtype", "")
if subtype == "ANGLE":
return [[math.degrees(getattr(self.node, self.prop_name))]]
return [[getattr(self.node, self.prop_name)]]
elif self.prop_type:
return [[getattr(self.node, self.prop_type)[self.prop_index]]]
elif default is not sentinel:
return default
else:
raise SvNoDataError(self)
def sv_get(self, default=sentinel, deepcopy=True):
self.num_matrices = 0
if self.is_linked and not self.is_output:
if is_vector_to_matrix(self):
# this means we're going to get a flat list of the incoming
# locations and convert those into matrices proper.
out = get_matrices_from_locs(SvGetSocket(self, deepcopy=True))
self.num_matrices = len(out)
return out
return SvGetSocket(self, deepcopy)
elif default is sentinel:
raise SvNoDataError(self)
else:
return default
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
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):
# 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
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()
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
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):
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)
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)
