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 process(self):
if not any(socket.is_linked for socket in self.outputs):
return
vertices_s = self.inputs['Vertices'].sv_get()
edges_s = self.inputs['Edges'].sv_get(default=[[]])
faces_s = self.inputs['Faces'].sv_get(default=[[]])
verts_out = []
idxs_out = []
for vertices, edges, faces in zip_long_repeat(vertices_s, edges_s,
faces_s):
bm = bmesh_from_pydata(vertices, edges, faces)
bm.faces.index_update()
parser = SvQuadGridParser(bm)
new_idxs = parser.get_verts_sequence()
new_verts = parser.get_ordered_verts()
if self.reverse_rows:
new_idxs = list(reversed(new_idxs))
new_verts = list(reversed(new_verts))
if self.reverse_cols:
new_idxs = [list(reversed(row)) for row in new_idxs]
new_verts = [list(reversed(row)) for row in new_verts]
if self.transpose:
new_idxs = transpose_list(new_idxs)
new_verts = transpose_list(new_verts)
if self.join_rows:
new_idxs = sum(new_idxs, [])
new_verts = sum(new_verts, [])
bm.free()
verts_out.append(new_verts)
idxs_out.append(new_idxs)
self.outputs['Vertices'].sv_set(verts_out)
self.outputs['Indexes'].sv_set(idxs_out)
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()
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)