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)