def process(self): if not any(socket.is_linked for socket in self.outputs): return curves_s = self.inputs['Curve'].sv_get() curves_s = ensure_nesting_level(curves_s, 2, data_types=(SvCurve, )) src_point_s = self.inputs['Point'].sv_get() src_point_s = ensure_nesting_level(src_point_s, 4) points_out = [] t_out = [] for curves, src_points_i in zip_long_repeat(curves_s, src_point_s): for curve, src_points in zip_long_repeat(curves, src_points_i): new_points = [] new_t = [] for src_point in src_points: src_point = np.array(src_point) result = ortho_project_curve(src_point, curve, init_samples=self.samples) if self.nearest: t = result.nearest_u point = result.nearest.tolist() new_t.append(t) new_points.append(point) else: new_t.extend(result.us) new_points.extend(result.points) points_out.append(new_points) t_out.append(new_t) self.outputs['Point'].sv_set(points_out) self.outputs['T'].sv_set(t_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return curves_s = self.inputs['Curve'].sv_get() curves_s = ensure_nesting_level(curves_s, 2, data_types=(SvCurve, )) frames_s = self.inputs['Frames'].sv_get() # list of frames per curve frames_s = ensure_nesting_level(frames_s, 3, data_types=(Matrix, )) ts_s = self.inputs['T'].sv_get() # list of T values per curve ts_s = ensure_nesting_level(ts_s, 3) tolerance = 10**(-self.accuracy) frames_out = [] for curves, frames_i, ts_i in zip_long_repeat( curves_s, frames_s, ts_s): for curve, frames, ts in zip_long_repeat( curves, frames_i, ts_i): new_frames = interpolate_frames(curve, frames, self.z_axis, ts, init_samples=self.samples + 1, tolerance=tolerance) if self.join: frames_out.extend(new_frames) else: frames_out.append(new_frames) self.outputs['Frame'].sv_set(frames_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surfaces_s = self.inputs['Surface'].sv_get() surfaces_s = ensure_nesting_level(surfaces_s, 2, data_types=(SvSurface, )) curves_s = self.inputs['Curve'].sv_get() curves_s = ensure_nesting_level(curves_s, 2, data_types=(SvCurve, )) tolerance = 10**(-self.accuracy) points_out = [] u_out = [] for surfaces, curves in zip_long_repeat(surfaces_s, curves_s): for surface, curve in zip_long_repeat(surfaces, curves): result = intersect_curve_surface( curve, surface, init_samples=self.curve_samples, raycast_samples=self.raycast_samples, tolerance=tolerance, raycast_method=self.raycast_method) new_points = [p[1] for p in result] new_u = [p[0] for p in result] points_out.append(new_points) u_out.append(new_u) self.outputs['Point'].sv_set(points_out) self.outputs['T'].sv_set(u_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surface_s = self.inputs['Surface'].sv_get() umin_s = self.inputs['NewUMin'].sv_get() umax_s = self.inputs['NewUMax'].sv_get() vmin_s = self.inputs['NewVMin'].sv_get() vmax_s = self.inputs['NewVMax'].sv_get() surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface, )) umin_s = ensure_nesting_level(umin_s, 2) umax_s = ensure_nesting_level(umax_s, 2) vmin_s = ensure_nesting_level(vmin_s, 2) vmax_s = ensure_nesting_level(vmax_s, 2) surface_out = [] for surfaces, umins, umaxs, vmins, vmaxs in zip_long_repeat( surface_s, umin_s, umax_s, vmin_s, vmax_s): new_surfaces = [] for surface, u_min, u_max, v_min, v_max in zip_long_repeat( surfaces, umins, umaxs, vmins, vmaxs): new_surface = SvReparametrizedSurface(surface, u_min, u_max, v_min, v_max) new_surfaces.append(new_surface) surface_out.append(new_surfaces) self.outputs['Surface'].sv_set(surface_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return face_surfaces_s = self.inputs['SolidFace'].sv_get() face_surfaces_s = ensure_nesting_level(face_surfaces_s, 2, data_types=(SvSurface, )) offset_s = self.inputs['Vector'].sv_get() offset_s = ensure_nesting_level(offset_s, 3) solids_out = [] for face_surfaces, offsets in zip_long_repeat(face_surfaces_s, offset_s): #new_solids = [] for face_surface, offset in zip_long_repeat( face_surfaces, offsets): if not is_solid_face_surface(face_surface): # face_surface is an instance of SvSurface, # but not a instance of SvFreeCadNurbsSurface self.debug( "Surface %s is not a face of a solid, will convert automatically", face_surface) face_surface = surface_to_freecad( face_surface, make_face=True) # SvFreeCadNurbsSurface fc_face = face_surface.face fc_offset = Base.Vector(*offset) shape = fc_face.extrude(fc_offset) solids_out.append(shape) #solids_out.append(new_solids) self.outputs['Solid'].sv_set(solids_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 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 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(socket.is_linked for socket in self.outputs): return surface_s = self.inputs['Surface'].sv_get() surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface,)) fields_s = self.inputs['Field'].sv_get() fields_s = ensure_nesting_level(fields_s, 2, data_types=(SvScalarField,)) if self.inputs['StartUV'].is_linked: start_s = self.inputs['StartUV'].sv_get() start_s = ensure_nesting_level(start_s, 4) else: start_s = [[[None]]] uv_out = [] point_out = [] for surfaces, fields, start_i in zip_long_repeat(surface_s, fields_s, start_s): new_uv = [] new_points = [] for surface, field, starts in zip_long_repeat(surfaces, fields, start_i): uvs = self.solve(surface, field, starts) uv_points = [(u, v, 0) for u,v in uvs] us = uvs[:,0] vs = uvs[:,1] points = surface.evaluate_array(us, vs) new_uv.extend(uv_points) new_points.extend(points.tolist()) uv_out.append(new_uv) point_out.append(new_points) self.outputs['Point'].sv_set(point_out) self.outputs['UVPoint'].sv_set(uv_out)
def get_inputs(self): factor1_s = self.inputs['Factor1'].sv_get() factor2_s = self.inputs['Factor2'].sv_get() factor1_s = ensure_nesting_level(factor1_s, 2) factor2_s = ensure_nesting_level(factor2_s, 2) if self.mode == 'TWO': curve1_s = self.inputs['Curve1'].sv_get() curve2_s = self.inputs['Curve2'].sv_get() if isinstance(curve1_s[0], SvCurve): curve1_s = [curve1_s] if isinstance(curve2_s[0], SvCurve): curve2_s = [curve2_s] for curve1s, curve2s, factor1s, factor2s in zip_long_repeat(curve1_s, curve2_s, factor1_s, factor2_s): for curve1, curve2, factor1, factor2 in zip_long_repeat(curve1s, curve2s, factor1s, factor2s): yield curve1, curve2, factor1, factor2 else: curves_s = self.inputs['Curves'].sv_get() if isinstance(curves_s[0], SvCurve): curves_s = [curves_s] for curves, factor1s, factor2s in zip_long_repeat(curves_s, factor1_s, factor2_s): factor1s = repeat_last_for_length(factor1s, len(curves)) factor2s = repeat_last_for_length(factor2s, len(curves)) for curve1, curve2, factor1, factor2 in zip(curves, curves[1:], factor1s, factor2s): yield curve1, curve2, factor1, factor2 if self.cyclic: yield curves[-1], curves[0], factor1s[-1], factor2s[-1]
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() tmin_s = self.inputs['TMin'].sv_get() tmax_s = self.inputs['TMax'].sv_get() tmin_s = ensure_nesting_level(tmin_s, 2) tmax_s = ensure_nesting_level(tmax_s, 2) if isinstance(curve_s[0], SvCurve): curve_s = [curve_s] curve_out = [] for curves, tmins, tmaxs in zip_long_repeat(curve_s, tmin_s, tmax_s): new_curves = [] for curve, t_min, t_max in zip_long_repeat(curves, tmins, tmaxs): new_curve = curve_segment(curve, t_min, t_max, self.rescale) new_curves.append(new_curve) if self.join: curve_out.extend(new_curves) else: curve_out.append(new_curves) self.outputs['Segment'].sv_set(curve_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surfaces_s = self.inputs['Surface'].sv_get() surfaces_s = ensure_nesting_level(surfaces_s, 2, data_types=(SvSurface, )) src_point_s = self.inputs['Point'].sv_get() src_point_s = ensure_nesting_level(src_point_s, 4) points_out = [] uv_out = [] for surfaces, src_points_i in zip_long_repeat( surfaces_s, src_point_s): for surface, src_points in zip_long_repeat( surfaces, src_points_i): new_points = [] new_uv = [] for src_point in src_points: src_point = np.array(src_point) u, v, point = ortho_project_surface( src_point, surface, init_samples=self.samples) new_uv.append((u, v, 0)) new_points.append(point) points_out.append(new_points) uv_out.append(new_uv) self.outputs['Point'].sv_set(points_out) self.outputs['UVPoint'].sv_set(uv_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() vertices_s = ensure_nesting_level(vertices_s, 4) fields_s = self.inputs['Field'].sv_get() fields_s = ensure_nesting_level(fields_s, 2, data_types=(SvScalarField, )) values_out = [] for fields, vertices_i in zip_long_repeat(fields_s, vertices_s): for field, vertices in zip_long_repeat(fields, vertices_i): if len(vertices) == 0: new_values = [] elif len(vertices) == 1: vertex = vertices[0] value = field.evaluate(*vertex) new_values = [value] else: XYZ = np.array(vertices) xs = XYZ[:, 0] ys = XYZ[:, 1] zs = XYZ[:, 2] new_values = field.evaluate_grid(xs, ys, zs).tolist() values_out.append(new_values) self.outputs['Value'].sv_set(values_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return profile_s = self.inputs['Curve'].sv_get() resolution_s = self.inputs['Resolution'].sv_get() radius_s = self.inputs['Radius'].sv_get() profile_s = ensure_nesting_level(profile_s, 2, data_types=(SvCurve, )) resolution_s = ensure_nesting_level(resolution_s, 2) radius_s = ensure_nesting_level(radius_s, 2) surface_out = [] for profiles, radiuses, resolutions in zip_long_repeat( profile_s, radius_s, resolution_s): new_surfaces = [] for profile, radius, resolution in zip_long_repeat( profiles, radiuses, resolutions): surface = SvConstPipeSurface(profile, radius, algorithm=self.algorithm, resolution=resolution) new_surfaces.append(surface) surface_out.append(new_surfaces) self.outputs['Surface'].sv_set(surface_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() if isinstance(profile_s[0], SvCurve): profile_s = [profile_s] if isinstance(taper_s[0], SvCurve): taper_s = [taper_s] point_s = ensure_nesting_level(point_s, 3) direction_s = ensure_nesting_level(direction_s, 3) surface_out = [] for profiles, tapers, points, directions in zip_long_repeat( profile_s, taper_s, point_s, direction_s): for profile, taper, point, direction in zip_long_repeat( profiles, tapers, points, directions): surface = SvTaperSweepSurface(profile, taper, np.array(point), np.array(direction)) surface_out.append(surface) self.outputs['Surface'].sv_set(surface_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return point_s = self.inputs['Point'].sv_get() direction_s = self.inputs['Direction'].sv_get() curve_s = self.inputs['Profile'].sv_get() v_min_s = self.inputs['AngleFrom'].sv_get() v_max_s = self.inputs['AngleTo'].sv_get() if isinstance(curve_s[0], SvCurve): curve_s = [curve_s] point_s = ensure_nesting_level(point_s, 3) direction_s = ensure_nesting_level(direction_s, 3) v_min_s = ensure_nesting_level(v_min_s, 2) v_max_s = ensure_nesting_level(v_max_s, 2) surface_out = [] for curves, points, directions, v_mins, v_maxs in zip_long_repeat( curve_s, point_s, direction_s, v_min_s, v_max_s): for curve, point, direction, v_min, v_max in zip_long_repeat( curves, points, directions, v_mins, v_maxs): origin = self.origin == 'GLOBAL' surface = SvRevolutionSurface.build(curve, np.array(point), np.array(direction), v_min, v_max, global_origin=origin) surface_out.append(surface) self.outputs['Surface'].sv_set(surface_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return face1_surfaces_s = self.inputs['SolidFace1'].sv_get() face1_surfaces_s = ensure_nesting_level(face1_surfaces_s, 2, data_types=(SvSurface, )) face2_surfaces_s = self.inputs['SolidFace2'].sv_get() face2_surfaces_s = ensure_nesting_level(face2_surfaces_s, 2, data_types=(SvSurface, )) solids_out = [] for face1_surfaces, face2_surfaces in zip_long_repeat( face1_surfaces_s, face2_surfaces_s): for face1_surface, face2_surface in zip_long_repeat( face1_surfaces, face2_surfaces): if not is_solid_face_surface(face1_surface): face1_surface = surface_to_freecad( face1_surface, make_face=True) # SvFreeCadNurbsSurface if not is_solid_face_surface(face2_surface): face2_surface = surface_to_freecad( face2_surface, make_face=True) # SvFreeCadNurbsSurface solid = self.make_solid(face1_surface, face2_surface) solids_out.append(solid) self.outputs['Solid'].sv_set(solids_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return t_min_s = self.inputs['TMin'].sv_get() t_max_s = self.inputs['TMax'].sv_get() t_min_s = ensure_nesting_level(t_min_s, 2) t_max_s = ensure_nesting_level(t_max_s, 2) var_names = self.get_variables() inputs = self.get_input() input_values = [inputs.get(name, [[0]]) for name in var_names] if var_names: parameters = match_long_repeat([t_min_s, t_max_s] + input_values) else: parameters = [t_min_s, t_max_s] curves_out = [] for t_mins, t_maxs, *objects in zip(*parameters): if var_names: var_values_s = zip_long_repeat(t_mins, t_maxs, *objects) else: var_values_s = zip_long_repeat(t_mins, t_maxs) for t_min, t_max, *var_values in var_values_s: variables = dict(zip(var_names, var_values)) function = self.make_function(variables) if self.use_numpy_function: function_vector = self.make_function_vector(variables) else: function_vector = None new_curve = SvLambdaCurve(function, function_vector) new_curve.u_bounds = (t_min, t_max) curves_out.append(new_curve) self.outputs['Curve'].sv_set(curves_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return field_s = self.inputs['Field'].sv_get() verts_s = self.inputs['Vertices'].sv_get() iso_value_s = self.inputs['IsoValue'].sv_get() field_s = ensure_nesting_level(field_s, 2, data_types=(SvScalarField, )) verts_s = ensure_nesting_level(verts_s, 4) iso_value_s = ensure_nesting_level(iso_value_s, 2) verts_out = [] threshold = 10**(-self.accuracy) for fields, verts_i, iso_value_i in zip_long_repeat( field_s, verts_s, iso_value_s): for field, verts, iso_value in zip_long_repeat( fields, verts_i, iso_value_i): verts = np.array(verts) new_verts = solve(field, verts, iso_value, maxiter=self.maxiter, threshold=threshold).tolist() 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 radiuses_s = self.inputs['Radiuses'].sv_get() radiuses_s = ensure_nesting_level(radiuses_s, 3) center_s = self.inputs['Center'].sv_get() center_s = ensure_nesting_level(center_s, 3) major_radius_s = self.inputs['MajorRadius'].sv_get() major_radius_s = ensure_nesting_level(major_radius_s, 2) curves_out = [] centers_out = [] radius_out = [] for radiuses, centers, major_radiuses in zip_long_repeat(radiuses_s, center_s, major_radius_s): for radiuses, center, major_radius in zip_long_repeat(radiuses, centers, major_radiuses): center_2d = self.to_2d(center) enclosure = circlify.Circle(x=center_2d[0], y=center_2d[1], r=major_radius) circles = circlify.circlify(radiuses, target_enclosure=enclosure, show_enclosure=self.show_enclosure) curves = [self.circle_to_curve(center, circle) for circle in circles] curves_out.extend(curves) centers_out.append([tuple(curve.center) for curve in curves]) radius_out.append([curve.radius for curve in curves]) self.outputs['Circles'].sv_set(curves_out) self.outputs['Centers'].sv_set(centers_out) self.outputs['Radiuses'].sv_set(radius_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return surface_s = self.inputs['Surface'].sv_get() u_min_s = self.inputs['UMin'].sv_get() u_max_s = self.inputs['UMax'].sv_get() v_min_s = self.inputs['VMin'].sv_get() v_max_s = self.inputs['VMax'].sv_get() u_min_s = ensure_nesting_level(u_min_s, 2) u_max_s = ensure_nesting_level(u_max_s, 2) v_min_s = ensure_nesting_level(v_min_s, 2) v_max_s = ensure_nesting_level(v_max_s, 2) if isinstance(surface_s[0], SvSurface): surface_s = [surface_s] surface_out = [] for surfaces, u_mins, u_maxs, v_mins, v_maxs in zip_long_repeat( surface_s, u_min_s, u_max_s, v_min_s, v_max_s): for surface, u_min, u_max, v_min, v_max in zip_long_repeat( surfaces, u_mins, u_maxs, v_mins, v_maxs): new_surface = SvSurfaceSubdomain(surface, (u_min, u_max), (v_min, v_max)) surface_out.append(new_surface) self.outputs['Surface'].sv_set(surface_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return face_surfaces_s = self.inputs['SolidFace'].sv_get() face_surfaces_s = ensure_nesting_level(face_surfaces_s, 2, data_types=(SvSurface,)) offset_s = self.inputs['Offset'].sv_get() offset_s = ensure_nesting_level(offset_s, 2) tolerance_s = self.inputs['Tolerance'].sv_get() tolerance_s = ensure_nesting_level(tolerance_s, 2) solids_out = [] for face_surfaces, offsets, tolerances in zip_long_repeat(face_surfaces_s, offset_s, tolerance_s): #new_solids = [] for face_surface, offset, tolerance in zip_long_repeat(face_surfaces, offsets, tolerances): if not is_solid_face_surface(face_surface): # face_surface is an instance of SvSurface, # but not a instance of SvFreeCadNurbsSurface self.debug("Surface %s is not a face of a solid, will convert automatically", face_surface) face_surface = surface_to_freecad(face_surface, make_face=True) # SvFreeCadNurbsSurface continuity = face_surface.get_min_continuity() if continuity >= 0 and continuity < 1: raise Exception("This node requires at least C1 continuity of the surface; only C0 is guaranteed by surface's knotvector") fc_face = face_surface.face shape = fc_face.makeOffsetShape(offset, tolerance, fill=True) solids_out.append(shape) #solids_out.append(new_solids) self.outputs['Solid'].sv_set(solids_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() center_s = self.inputs['Center'].sv_get() direction_s = self.inputs['Direction'].sv_get() radius_s = self.inputs['Radius'].sv_get() coeff_s = self.inputs['Coefficient'].sv_get() if isinstance(curve_s[0], SvCurve): curve_s = [curve_s] center_s = ensure_nesting_level(center_s, 3) direction_s = ensure_nesting_level(direction_s, 3) radius_s = ensure_nesting_level(radius_s, 2) coeff_s = ensure_nesting_level(coeff_s, 2) curves_out = [] for curves, centers, directions, radiuses, coeffs in zip_long_repeat(curve_s, center_s, direction_s, radius_s, coeff_s): for curve, center, direction, radius, coeff in zip_long_repeat(curves, centers, directions, radiuses, coeffs): if self.use_nurbs: new_curve = self._cast_nurbs(curve, np.array(center), np.array(direction), radius, coeff) else: new_curve = self._cast_generic(curve, np.array(center), np.array(direction), radius, coeff) curves_out.append(new_curve) self.outputs['Curve'].sv_set(curves_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() 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) curve_out = [] for curves, offsets, vectors, resolutions in zip_long_repeat(curve_s, offset_s, vector_s, resolution_s): new_curves = [] for curve, offset, vector, resolution in zip_long_repeat(curves, offsets, vectors, resolutions): if self.mode == 'X': vector = [offset, 0, 0] elif self.mode == 'Y': vector = [0, offset, 0] vector = np.array(vector) new_curve = SvOffsetCurve(curve, vector, 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 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 face_surface_s = self.inputs['Profile'].sv_get() face_surface_s = ensure_nesting_level(face_surface_s, 2, data_types=(SvSurface, )) curve_s = self.inputs['Path'].sv_get() curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve, )) solid_out = [] for face_surfaces, curves in zip_long_repeat(face_surface_s, curve_s): for face_surface, curve in zip_long_repeat(face_surfaces, curves): if not is_solid_face_surface(face_surface): face_surface = surface_to_freecad(face_surface, make_face=True) curve = curve_to_freecad_nurbs(curve) if curve is None: raise Exception("Path curve is not a NURBS!") solid = self.make_solid(face_surface.face, curve.curve) solid_out.append(solid) self.outputs['Solid'].sv_set(solid_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return curve_s = self.inputs['Curve'].sv_get() t_before_s = self.inputs['StartExt'].sv_get() t_after_s = self.inputs['EndExt'].sv_get() t_before_s = ensure_nesting_level(t_before_s, 2) t_after_s = ensure_nesting_level(t_after_s, 2) curve_s = ensure_nesting_level(curve_s, 2, data_types=(SvCurve, )) start_out = [] end_out = [] curve_out = [] for curves, t_before_i, t_after_i in zip_long_repeat( curve_s, t_before_s, t_after_s): for curve, t_before, t_after in zip_long_repeat( curves, t_before_i, t_after_i): start_extent, end_extent = self.extend_curve( curve, t_before, t_after) start_out.append(start_extent) end_out.append(end_extent) curves = [] if start_extent is not None: curves.append(start_extent) curves.append(curve) if end_extent is not None: curves.append(end_extent) new_curve = concatenate_curves(curves) curve_out.append(new_curve) self.outputs['StartExtent'].sv_set(start_out) self.outputs['EndExtent'].sv_set(end_out) self.outputs['ExtendedCurve'].sv_set(curve_out)
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() vertices_s = ensure_nesting_level(vertices_s, 3) degree_s = ensure_nesting_level(degree_s, 2) curve_out = [] points_out = [] for vertices, degree in zip_long_repeat(vertices_s, degree_s): if isinstance(degree, (tuple, list)): degree = degree[0] n = len(vertices) npoints = degree + 1 vertices = np.array(vertices) #xdata = np.linspace(0, 1, num=n) xdata = Spline.create_knots(vertices, metric=self.metric) ydata = np.ravel(vertices) p0 = init_guess(vertices, npoints) popt, pcov = curve_fit(goal, xdata, ydata, p0) control_points = popt.reshape((npoints, 3)) curve = SvBezierCurve(control_points) curve_out.append(curve) points_out.append(control_points.tolist()) self.outputs['Curve'].sv_set(curve_out) self.outputs['ControlPoints'].sv_set(points_out)
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 get_input(self): if self.input_mode == 'LIST': curve_list_s = self.inputs['Curves'].sv_get() curve_list_s = ensure_nesting_level(curve_list_s, 2, data_types=(SvCurve, )) for curves in curve_list_s: if len(curves) != 4: raise Exception( "List of curves must contain exactly 4 curve objects!") yield curves else: curve1_s = self.inputs['Curve1'].sv_get() curve2_s = self.inputs['Curve2'].sv_get() curve3_s = self.inputs['Curve3'].sv_get() curve4_s = self.inputs['Curve4'].sv_get() curve1_s = ensure_nesting_level(curve1_s, 1, data_types=(SvCurve, )) curve2_s = ensure_nesting_level(curve2_s, 1, data_types=(SvCurve, )) curve3_s = ensure_nesting_level(curve3_s, 1, data_types=(SvCurve, )) curve4_s = ensure_nesting_level(curve4_s, 1, data_types=(SvCurve, )) for curve1, curve2, curve3, curve4 in zip_long_repeat( curve1_s, curve2_s, curve3_s, curve4_s): yield [curve1, curve2, curve3, curve4]
def process(self): if not any(socket.is_linked for socket in self.outputs): return if not self.inputs['Vertices'].is_linked: return vertices_s = self.inputs['Vertices'].sv_get() vertices_s = ensure_nesting_level(vertices_s, 4) surfaces = self.inputs['Surface'].sv_get() surfaces = ensure_nesting_level(surfaces, 4) objects = match_long_repeat([vertices_s, surfaces]) result_vertices = [] for vertices, surface in zip(*objects): if self.transpose: surface = transpose_list(surface) #print("Surface: {} of {} of {}".format(type(surface), type(surface[0]), type(surface[0][0]))) spline = self.build_spline(surface) # uv_coords will be list[m] of lists[n] of 2-tuples of floats # number of "rows" and "columns" in uv_coords will match so of vertices. src_size_u, src_size_v, uv_coords = self.get_uv(vertices) if self.autoscale: u_index, v_index = self.get_other_axes() surface_flattened = [v for col in surface for v in col] scale_u = diameter(surface_flattened, u_index) / src_size_u scale_v = diameter(surface_flattened, v_index) / src_size_v scale_z = sqrt(scale_u * scale_v) else: scale_z = 1.0 if self.flip: scale_z = - scale_z new_vertices = [] for uv_row, vertices_row in zip(uv_coords,vertices): new_row = [] for ((u, v), src_vertex) in zip(uv_row, vertices_row): #print("UV: ({}, {}), SRC: {}".format(u, v, src_vertex)) spline_vertex = np.array(spline.eval(u, v)) spline_normal = np.array(spline.normal(u, v, h=self.normal_precision)) #print("Spline: M {}, N {}".format(spline_vertex, spline_normal)) # Coordinate of source vertex corresponding to orientation axis z = src_vertex[self.orient_axis] new_vertex = tuple(spline_vertex + scale_z * z * spline_normal) new_row.append(new_vertex) new_vertices.append(new_row) result_vertices.append(new_vertices) if not self.grouped: result_vertices = result_vertices[0] self.outputs['Vertices'].sv_set(result_vertices)
def process(self): if not any(socket.is_linked for socket in self.outputs): return if not self.inputs['Vertices'].is_linked: return vertices_s = self.inputs['Vertices'].sv_get() paths = self.inputs['Path'].sv_get() paths = ensure_nesting_level(paths, 3) objects = match_long_repeat([vertices_s, paths]) result_vertices = [] result_spline = [] for vertices, path in zip(*objects): # Scale orientation coordinate of input vertices to [0, 1] range # these values are used to calculate points on the spline t_values = np.array([vertex[self.orient_axis] for vertex in vertices]) m = t_values.min() M = t_values.max() object_size = M - m if object_size > 0.00001: t_values = (t_values - m) / object_size else: raise Exception("Size of provided object along axis {} is too small".format(self.orient_axis_)) if self.flip: t_values = 1.0 - t_values spline = self.build_spline(path) scale = spline.length(t_values) / object_size # These are points lying on the spline # (a projection of object to spline) spline_vertices = [Vector(v) for v in spline.eval(t_values).tolist()] spline_tangents = [Vector(v) for v in spline.tangent(t_values, h=self.tangent_precision).tolist()] new_vertices = [] for src_vertex, spline_vertex, spline_tangent in zip(vertices, spline_vertices, spline_tangents): # Scaling and rotation matrix matrix = self.get_matrix(spline_tangent, scale) # Source vertex projected to plane orthogonal to orientation axis src_vertex_projection = Vector(src_vertex) src_vertex_projection[self.orient_axis] = 0 # Scale and rotate the projection, then move it towards spline vertex new_vertex = matrix * Vector(src_vertex_projection) + spline_vertex new_vertices.append(new_vertex) result_vertices.append(new_vertices) self.outputs['Vertices'].sv_set(Vector_degenerate(result_vertices))