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)
