def process(self): if not any(socket.is_linked for socket in self.outputs): return curve1_s = self.inputs['Curve1'].sv_get() curve2_s = self.inputs['Curve2'].sv_get() curve1_s = ensure_nesting_level(curve1_s, 2, data_types=(SvCurve, )) curve2_s = ensure_nesting_level(curve2_s, 2, data_types=(SvCurve, )) points_out = [] t1_out = [] t2_out = [] for curve1s, curve2s in zip_long_repeat(curve1_s, curve2_s): new_points = [] new_t1 = [] new_t2 = [] for curve1, curve2 in self.match(curve1s, curve2s): curve1 = SvNurbsCurve.to_nurbs(curve1) if curve1 is None: raise Exception("Curve1 is not a NURBS") curve2 = SvNurbsCurve.to_nurbs(curve2) if curve2 is None: raise Exception("Curve2 is not a NURBS") if self.implementation == 'SCIPY': t1s, t2s, ps = self.process_native(curve1, curve2) else: t1s, t2s, ps = self.process_freecad(curve1, curve2) if self.check_intersection: if not ps: raise Exception("Some curves do not intersect!") if self.single: if len(ps) >= 1: ps = ps[0] t1s = t1s[0] t2s = t2s[0] new_points.append(ps) new_t1.append(t1s) new_t2.append(t2s) if self.split: n = len(curve1s) new_points = split_by_count(new_points, n) new_t1 = split_by_count(new_t1, n) new_t1 = transpose_list(new_t1) new_t2 = split_by_count(new_t2, n) points_out.append(new_points) t1_out.append(new_t1) t2_out.append(new_t2) self.outputs['Intersections'].sv_set(points_out) self.outputs['T1'].sv_set(t1_out) self.outputs['T2'].sv_set(t2_out)
def get_surface(self, spline, matrix): surface_degree_u = spline.order_u - 1 surface_degree_v = spline.order_v - 1 spline_points = split_by_count(spline.points, spline.point_count_u) if self.apply_matrix: control_points = [[list(matrix @ Vector(p.co[:3])) for p in row] for row in spline_points] else: control_points = [[tuple(p.co) for p in row] for row in spline_points] surface_weights = [[p.co[3] for p in row] for row in spline_points] if spline.use_cyclic_v: for row_idx in range(len(control_points)): control_points[row_idx].extend( control_points[row_idx][:spline.order_v]) if spline.use_cyclic_u: control_points.extend(control_points[:spline.order_u]) # Control points n_u_total = len(control_points) n_v_total = len(control_points[0]) if spline.use_cyclic_u: knots_u = list(range(n_u_total + spline.order_u)) else: knots_u = sv_knotvector.generate(surface_degree_u, n_u_total, clamped=spline.use_endpoint_u) self.debug("Auto knots U: %s", knots_u) if spline.use_cyclic_v: knots_v = list(range(n_v_total + spline.order_v)) else: knots_v = sv_knotvector.generate(surface_degree_v, n_v_total, clamped=spline.use_endpoint_v) self.debug("Auto knots V: %s", knots_v) surface_knotvector_u = knots_u surface_knotvector_v = knots_v new_surf = SvNurbsSurface.build(self.implementation, surface_degree_u, surface_degree_v, surface_knotvector_u, surface_knotvector_v, control_points, surface_weights, normalize_knots=True) if spline.use_cyclic_u: u_min = surface_knotvector_u[surface_degree_u] u_max = surface_knotvector_u[-surface_degree_u - 2] else: if spline.use_endpoint_u: u_min = min(surface_knotvector_u) u_max = max(surface_knotvector_u) else: u_min = surface_knotvector_u[surface_degree_u] u_max = surface_knotvector_u[-surface_degree_u - 1] if spline.use_cyclic_v: v_min = surface_knotvector_v[surface_degree_v] v_max = surface_knotvector_v[-surface_degree_v - 2] else: if spline.use_endpoint_v: v_min = min(surface_knotvector_v) v_max = max(surface_knotvector_v) else: v_min = surface_knotvector_v[surface_degree_v] v_max = surface_knotvector_v[-surface_degree_v - 1] new_surf.u_bounds = u_min, u_max new_surf.v_bounds = v_min, v_max return new_surf
def process(self): vertices_s = self.inputs['ControlPoints'].sv_get() has_weights = self.inputs['Weights'].is_linked weights_s = self.inputs['Weights'].sv_get(default=[[1.0]]) u_size_s = self.inputs['USize'].sv_get() knots_u_s = self.inputs['KnotsU'].sv_get(default=[[]]) knots_v_s = self.inputs['KnotsV'].sv_get(default=[[]]) degree_u_s = self.inputs['DegreeU'].sv_get() degree_v_s = self.inputs['DegreeV'].sv_get() if self.input_mode == '1D': vertices_s = ensure_nesting_level(vertices_s, 3) else: vertices_s = ensure_nesting_level(vertices_s, 4) surfaces_out = [] inputs = zip_long_repeat(vertices_s, weights_s, knots_u_s, knots_v_s, degree_u_s, degree_v_s, u_size_s) for vertices, weights, knots_u, knots_v, degree_u, degree_v, u_size in inputs: if isinstance(degree_u, (tuple, list)): degree_u = degree_u[0] if isinstance(degree_v, (tuple, list)): degree_v = degree_v[0] if isinstance(u_size, (list, tuple)): u_size = u_size[0] if self.surface_mode != 'NURBS': weights = None if self.surface_mode == 'NURBS': if self.input_mode == '1D': weights = repeat_last_for_length(weights, len(vertices), deepcopy=True) else: if isinstance(weights[0], (int, float)): weights = [weights] weights = repeat_last_for_length(weights, len(vertices), deepcopy=True) for verts_u, weights_u in zip(vertices, weights): fullList_deep_copy(weights_u, len(verts_u)) if self.input_mode == '1D': n_v = u_size n_u = len(vertices) // n_v vertices = split_by_count(vertices, n_u) if self.surface_mode == 'NURBS': weights = split_by_count(weights, n_u) if self.knot_mode == 'AUTO': if self.is_cyclic_v: for row_idx in range(len(vertices)): vertices[row_idx].extend(vertices[row_idx][:degree_v + 1]) if self.surface_mode == 'NURBS': weights[row_idx].extend( weights[row_idx][:degree_v + 1]) if self.is_cyclic_u: vertices.extend(vertices[:degree_u + 1]) if self.surface_mode == 'NURBS': weights.extend(weights[:degree_u + 1]) self.debug("UxV: %s x %s", len(vertices), len(vertices[0])) n_u_total = len(vertices) n_v_total = len(vertices[0]) if self.knot_mode == 'AUTO': if self.is_cyclic_u: knots_u = list(range(n_u_total + degree_u + 1)) else: knots_u = sv_knotvector.generate(degree_u, n_u_total) self.debug("Auto knots U: %s", knots_u) surf_knotvector_u = knots_u if self.is_cyclic_v: knots_v = list(range(n_v_total + degree_v + 1)) else: knots_v = sv_knotvector.generate(degree_v, n_v_total) self.debug("Auto knots V: %s", knots_v) surf_knotvector_v = knots_v else: surf_knotvector_u = knots_u surf_knotvector_v = knots_v new_surf = SvNurbsSurface.build(self.implementation, degree_u, degree_v, surf_knotvector_u, surf_knotvector_v, vertices, weights, self.normalize_knots) surf_knotvector_u = new_surf.get_knotvector_u().tolist() surf_knotvector_v = new_surf.get_knotvector_v().tolist() if self.is_cyclic_u: u_min = surf_knotvector_u[degree_u] u_max = surf_knotvector_u[-degree_u - 2] new_surf.u_bounds = u_min, u_max #print("U:",new_surf.u_bounds) else: u_min = min(surf_knotvector_u) u_max = max(surf_knotvector_u) new_surf.u_bounds = u_min, u_max if self.is_cyclic_v: v_min = surf_knotvector_v[degree_v] v_max = surf_knotvector_v[-degree_v - 2] new_surf.v_bounds = v_min, v_max #print("V:",new_surf.v_bounds) else: v_min = min(surf_knotvector_v) v_max = max(surf_knotvector_v) new_surf.v_bounds = v_min, v_max surfaces_out.append(new_surf) self.outputs['Surface'].sv_set(surfaces_out)
def process(self): vertices_s = self.inputs['Vertices'].sv_get() u_size_s = self.inputs['USize'].sv_get() degree_u_s = self.inputs['DegreeU'].sv_get() degree_v_s = self.inputs['DegreeV'].sv_get() if self.input_mode == '1D': vertices_s = ensure_nesting_level(vertices_s, 3) else: vertices_s = ensure_nesting_level(vertices_s, 4) surfaces_out = [] points_out = [] knots_u_out = [] knots_v_out = [] for vertices, degree_u, degree_v, u_size in zip_long_repeat( vertices_s, degree_u_s, degree_v_s, u_size_s): if isinstance(degree_u, (tuple, list)): degree_u = degree_u[0] if isinstance(degree_v, (tuple, list)): degree_v = degree_v[0] if isinstance(u_size, (tuple, list)): u_size = u_size[0] if self.input_mode == '1D': n_u = u_size n_v = len(vertices) // n_u else: n_u = len(vertices[0]) for i, verts_i in enumerate(vertices): if len(verts_i) != n_u: raise Exception( "Number of vertices in row #{} is not the same as in the first ({} != {})!" .format(i, n_u, len(verts_i))) vertices = sum(vertices, []) n_v = len(vertices) // n_u if geomdl is not None and self.nurbs_implementation == SvNurbsMaths.GEOMDL: surf = fitting.interpolate_surface( vertices, n_u, n_v, degree_u, degree_v, centripetal=self.centripetal) surf = SvGeomdlSurface(surf) else: vertices_np = np.array(split_by_count(vertices, n_v)) vertices_np = np.transpose(vertices_np, axes=(1, 0, 2)) surf = interpolate_nurbs_surface(degree_u, degree_v, vertices_np, metric=self.metric) points_out.append(surf.get_control_points().tolist()) knots_u_out.append(surf.get_knotvector_u().tolist()) knots_v_out.append(surf.get_knotvector_v().tolist()) surfaces_out.append(surf) self.outputs['Surface'].sv_set(surfaces_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['KnotsU'].sv_set(knots_u_out) self.outputs['KnotsV'].sv_set(knots_v_out)