def process(self):
if not any(s.is_linked for s in self.outputs):
return
params_in = [s.sv_get(deepcopy=False) for s in self.inputs[:4]]
params_in.append(self.inputs['Fill / Stroke'].sv_get(deepcopy=False,
default=[[None]]))
get_curves = self.outputs['Curves'].is_linked
shapes_out = []
curves_out = []
for params in zip(*mlr(params_in)):
shapes = []
for loc, rad_x, rad_y, angle, atts in zip(*mlr(params)):
shapes.append(SvgCircle(rad_x, rad_y, loc, angle, atts))
if get_curves:
center = curve_matrix(loc, angle, rad_x, rad_y)
curve = SvCircle(center, rad_x)
curve.u_bounds = (0, 2 * pi)
curves_out.append(curve)
if self.ungroup:
shapes_out.extend(shapes)
else:
shapes_out.append(SvgGroup(shapes))
self.outputs[0].sv_set(shapes_out)
self.outputs[1].sv_set(curves_out)
def process(self):
if not self.outputs[0].is_linked:
return
if self.mode == "CURVE":
curves_in = self.inputs['Curve'].sv_get(deepcopy=False)
atts_in = self.inputs['Fill / Stroke'].sv_get(deepcopy=False,
default=[[None]])
if isinstance(curves_in[0], SvCurve):
curves_in = [curves_in]
groups = []
for curves, atts in zip(*mlr([curves_in, atts_in])):
curves_out = []
for c, att in zip(*mlr([curves, atts])):
curves_out.append(SvgCurve(c, att, self))
groups.append(SvgGroup(curves_out))
self.outputs[0].sv_set(groups)
else:
verts_in = self.inputs['Vertices'].sv_get(deepcopy=True)
commands_in = self.inputs['Commands'].sv_get(deepcopy=True)
shapes = []
atts_in = self.inputs['Fill / Stroke'].sv_get(deepcopy=False,
default=[[None]])
for verts, commands, atts in zip(
*mlr([verts_in, commands_in, atts_in])):
shapes.append(SvgPath(verts, commands, atts, self))
self.outputs[0].sv_set(shapes)
def perspective_projection(verts_in, plane_in, distance):
verts_out = []
z_coord_out = []
for verts, plane in zip(*mlr([verts_in, plane_in])):
origin = plane.decompose()[0]
normal = ((plane @ Vector((0, 0, 1))) - origin).normalized()
plane_point = origin
focal_point = origin + normal * distance
inverted_matrix = plane.inverted()
vs = []
zs = []
for v in verts:
v_v = Vector(v)
ray = v_v - focal_point
line_dir = ray.normalized()
normal_dot_line_dir = normal.dot(line_dir)
if normal_dot_line_dir == 0:
new_v = v
else:
t = (normal.dot(plane_point) - normal.dot(v)) / normal_dot_line_dir
new_v = v_v + (line_dir * t)
point_2d = inverted_matrix @ new_v
vs.append([point_2d[0], point_2d[1], 0])
zs.append(ray.length)
verts_out.append(vs)
z_coord_out.append(zs)
return verts_out, z_coord_out
def process(self):
OutV, OutP = self.outputs
if not OutV.is_linked:
return
VertA, PolA, VertB, PolB, VertN, PolN = self.inputs
SMode = self.selected_mode
out = []
recursionlimit = sys.getrecursionlimit()
sys.setrecursionlimit(10000)
if not self.nest_objs:
for v1, p1, v2, p2 in zip(*mlr(
[VertA.sv_get(),
PolA.sv_get(),
VertB.sv_get(),
PolB.sv_get()])):
out.append(Boolean(v1, p1, v2, p2, SMode))
else:
vnest, pnest = VertN.sv_get(), PolN.sv_get()
First = Boolean(vnest[0], pnest[0], vnest[1], pnest[1], SMode)
if not self.out_last:
out.append(First)
for i in range(2, len(vnest)):
out.append(
Boolean(First[0], First[1], vnest[i], pnest[i], SMode))
First = out[-1]
else:
for i in range(2, len(vnest)):
First = Boolean(First[0], First[1], vnest[i], pnest[i],
SMode)
out.append(First)
sys.setrecursionlimit(recursionlimit)
OutV.sv_set([i[0] for i in out])
if OutP.is_linked:
OutP.sv_set([i[1] for i in out])
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
solids_in = self.inputs[0].sv_get()
points = self.inputs[1].sv_get()
inside_mask = []
inside_verts_out = []
outside_verts_out = []
for solid, points, in zip(*mlr([solids_in, points])):
verts_inside = []
verts_outside = []
is_inside = []
for v in points:
v_is_inside = solid.isInside(Base.Vector(v),
self.tolerance,
self.in_surface)
is_inside.append(v_is_inside)
if v_is_inside:
verts_inside.append(v)
else:
verts_outside.append(v)
inside_mask.append(is_inside)
inside_verts_out.append(verts_inside)
outside_verts_out.append(verts_outside)
self.outputs['Mask'].sv_set(inside_mask)
self.outputs['Inside Vertices'].sv_set(inside_verts_out)
self.outputs['Outside Vertices'].sv_set(outside_verts_out)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
verts_s = self.inputs[0].sv_get(deepcopy=False)
faces_s = self.inputs[1].sv_get(deepcopy=False)
solids = []
faces = []
for verts, faces in zip(*mlr([verts_s, faces_s])):
tri_faces = ensure_triangles(verts, faces, True)
faces_t = []
for f in tri_faces:
faces_t.append([verts[c] for c in f])
mesh = Mesh.Mesh(faces_t)
shape = Part.Shape()
shape.makeShapeFromMesh(mesh.Topology, self.precision)
if self.refine_solid:
shape = shape.removeSplitter()
solid = Part.makeSolid(shape)
solids.append(solid)
self.outputs['Solid'].sv_set(solids)
def standard_mesher(self):
solids = self.inputs[self["shape_type"]].sv_get()
surface_deviation = self.inputs["Surface Deviation"].sv_get()[0]
angle_deviation = self.inputs["Angle Deviation"].sv_get()[0]
verts = []
faces = []
for solid, s_dev, ang_dev in zip(
*mlr([solids, surface_deviation, angle_deviation])):
if self.shape_type == 'Solid':
shape = solid
else:
shape = solid.face
mesh = MeshPart.meshFromShape(
Shape=shape,
LinearDeflection=s_dev,
AngularDeflection=math.radians(ang_dev),
Relative=self.relative_surface_deviation)
verts.append([v[:] for v in mesh.Topology[0]])
b_faces = mesh.Topology[1]
b_faces = clean(b_faces).tolist() if is_triangles_only(
b_faces) else b_faces
faces.append(b_faces)
return verts, faces
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
solids_in = self.inputs[0].sv_get(deepcopy=False)
matrixes = self.inputs[1].sv_get(deepcopy=False)
slices = []
slices_face = []
faces_add = slices_face.extend if self.flat_output else slices_face.append
slices_add = slices.extend if self.flat_output else slices.append
for solid, matrix in zip(*mlr([solids_in, matrixes])):
location = matrix.decompose()[0]
norm = (matrix @ Vector((0, 0, 1))) - location
dist = norm.dot(location)
wires = solid.slice(Base.Vector(norm), dist)
edges_curves = []
faces = []
for wire in wires:
for edge in wire.Edges:
curve = SvSolidEdgeCurve(edge)
edges_curves.append(curve)
if wires:
face = Part.Face(wires)
faces.append(SvSolidFaceSurface(face).to_nurbs())
if faces:
faces_add(faces)
if edges_curves:
slices_add(edges_curves)
self.outputs['Edges'].sv_set(slices)
self.outputs['Faces'].sv_set(slices_face)
def process(self):
if not self.outputs[0].is_linked:
return
verts_in = self.inputs['Vertices'].sv_get(deepcopy=True)
pols_in = self.inputs['Polygons / Edges'].sv_get(deepcopy=True)
planes_in = self.inputs['Projection Plane'].sv_get(deepcopy=True,
default=[Matrix()])
offset_in = self.inputs['Offset'].sv_get(deepcopy=True,
default=[Matrix()])
atts_in = self.inputs['Fill / Stroke'].sv_get(deepcopy=False,
default=None)
shapes = []
verts_to_project = []
if self.projection_mode == 'Orthogrphic':
projection_func = ortho_projection_func_dict[self.projection_plane]
else:
projection_func = perspective_proyection
for verts, pols, p_plane, offset, atts in zip(
*mlr([verts_in, pols_in, planes_in, offset_in, atts_in])):
verts_p = projection_func(verts, p_plane, offset)
verts_to_project.append(verts_p)
shapes.append(SvgMesh(verts_p, pols, atts, self))
self.outputs[0].sv_set(shapes)
self.outputs[1].sv_set(verts_to_project)
def process(self):
OutV, OutP = self.outputs
if not OutV.is_linked:
return
VertA, PolA, VertB, PolB, VertN, PolN = self.inputs
SMode = self.selected_mode
out = []
if not self.nest_objs:
for v1, p1, v2, p2 in zip(*mlr([VertA.sv_get(), PolA.sv_get(), VertB.sv_get(), PolB.sv_get()])):
out.append(Boolean(v1, p1, v2, p2, SMode))
else:
vnest, pnest = VertN.sv_get(), PolN.sv_get()
First = Boolean(vnest[0], pnest[0], vnest[1], pnest[1], SMode)
if not self.out_last:
out.append(First)
for i in range(2, len(vnest)):
out.append(Boolean(First[0], First[1], vnest[i], pnest[i], SMode))
First = out[-1]
else:
for i in range(2, len(vnest)):
First = Boolean(First[0], First[1], vnest[i], pnest[i], SMode)
out.append(First)
OutV.sv_set([i[0] for i in out])
if OutP.is_linked:
OutP.sv_set([i[1] for i in out])
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
solids_in = self.inputs[0].sv_get()
radius_start_s = self.inputs[1].sv_get()[0]
radius_end_s = self.inputs[2].sv_get()[0]
mask_s = self.inputs[3].sv_get(default=[[1]])
solids = []
for solid, r_s, r_e, mask in zip(*mlr([solids_in, radius_start_s, radius_end_s, mask_s])):
selected_edges = []
fullList(mask, len(solid.Edges))
for edge, m in zip(solid.Edges, mask):
if m:
selected_edges.append(edge)
if selected_edges:
solid_o = solid.makeFillet(r_s, r_e, selected_edges)
else:
solid_o = solid
solids.append(solid_o)
self.outputs['Solid'].sv_set(solids)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
solids_in = self.inputs[0].sv_get(deepcopy=False)
offsets = self.inputs[1].sv_get(deepcopy=False)[0]
solids = []
for solid_base, offset in zip(*mlr([solids_in, offsets])):
shape = solid_base.makeOffsetShape(offset,
self.tolerance,
inter=self.intersection,
join=self['join_type'])
if self.refine_solid:
shape = shape.removeSplitter()
try:
valid = shape.isValid()
solid = Part.makeSolid(shape)
except Exception as e:
self.warning("Shape is not valid: %s: %s", shape, e)
continue
solids.append(solid)
self.outputs['Solid'].sv_set(solids)
def draw_sorted_pols(verts, polygons, attributes, document, z_func):
v_pols = []
z_key = []
svg = ''
for p in polygons:
v_pol = []
z_c = []
for c in p:
v_pol.append(verts[c])
z_c.append(verts[c][2])
v_pols.append(v_pol)
# z_key.append(sum(z_c)/len(z_c))
z_key.append(z_func(z_c))
sorted_v_pols = [x for _, x in sorted(zip(z_key, v_pols))]
func = draw_edge if len(polygons[0]) < 3 else draw_pol
scale = document.scale
height = document.height
for p, atts in zip(*mlr([sorted_v_pols, attributes])):
svg += func(p, scale, height)
if atts:
svg += atts.draw(document)
svg += '/>\n'
return svg
def single_intersect(self):
solids_a = self.inputs[0].sv_get()
solids_b = self.inputs[1].sv_get()
solids = []
for solid_a, solid_b in zip(*mlr([solids_a, solids_b])):
solids.append(solid_a.common(solid_b))
self.outputs[0].sv_set(solids)
def process(self):
if not self.outputs[0].is_linked:
return
params_in = [s.sv_get(deepcopy=False) for s in self.inputs[:4]]
texts_out = []
params_in.append(self.inputs['Fill / Stroke'].sv_get(deepcopy=False, default=None))
font_family = self.user_font if self.font_family == 'user' else self.font_family
print("process")
for params in zip(*mlr(params_in)):
svg_texts = []
for loc, text, size, angle, atts in zip(*mlr(params)):
svg_texts.append(SvgText(loc, text, size, angle, self.weight, atts, font_family, self.font_alignment))
texts_out.append(SvgGroup(svg_texts))
self.outputs[0].sv_set(texts_out)
def single_difference(self):
solids_a = self.inputs[0].sv_get()
solids_b = self.inputs[1].sv_get()
solids = []
for solid_a, solid_b in zip(*mlr([solids_a, solids_b])):
shape = solid_a.cut(solid_b)
solids.append(shape)
self.outputs[0].sv_set(solids)
def process(self):
if not self.outputs[0].is_linked:
return
params_in = [
s.sv_get(deepcopy=False, default=[[None]]) for s in self.inputs
]
attributes_out = []
for params in zip(*mlr(params_in)):
attributes = []
dash_pattern = params[-1]
for fill_color, stroke_color, stroke_width in zip(
*mlr(params[:-1])):
attributes.append(
SvgAttributes(fill_color, stroke_width, stroke_color,
dash_pattern, self))
attributes_out.append(attributes)
self.outputs[0].sv_set(attributes_out)
def process(self):
if not self.outputs[0].is_linked:
return
params_in = [s.sv_get(deepcopy=False) for s in self.inputs[:6]]
texts_out = []
params_in.append(self.inputs['Text Fill / Stroke'].sv_get(deepcopy=False, default=[[None]]))
params_in.append(self.inputs['Lines Fill / Stroke'].sv_get(deepcopy=False, default=[[None]]))
font_family = self.user_font if self.font_family == 'user' else self.font_family
for params in zip(*mlr(params_in)):
svg_texts = []
for local_params in zip(*mlr(params)):
svg_texts.append(SvgDimension(*local_params, font_family, self))
texts_out.append(SvgGroup(svg_texts))
self.outputs[0].sv_set(texts_out)
def single_union(self):
solids_a = self.inputs[0].sv_get()
solids_b = self.inputs[1].sv_get()
solids = []
for solid_a, solid_b in zip(*mlr([solids_a, solids_b])):
solid_out = solid_a.fuse(solid_b)
if self.refine_solid:
solid_out = solid_out.removeSplitter()
solids.append(solid_out)
self.outputs[0].sv_set(solids)
def process(self):
V1, V2, N, R = [i.sv_get() for i in self.inputs]
out = []
Co, ind, dist = self.outputs
find_n = self.mode == "find_n"
for v, v2, k in zip(V1, V2, (N if find_n else R)):
kd = mathutils.kdtree.KDTree(len(v))
for idx, co in enumerate(v):
kd.insert(co, idx)
kd.balance()
if find_n:
out.extend([kd.find_n(vert, num) for vert, num in zip(*mlr([v2, k]))])
else:
out.extend([kd.find_range(vert, dist) for vert, dist in zip(*mlr([v2, k]))])
if Co.is_linked:
Co.sv_set([[i[0][:] for i in i2] for i2 in out])
if ind.is_linked:
ind.sv_set([[i[1] for i in i2] for i2 in out])
if dist.is_linked:
dist.sv_set([[i[2] for i in i2] for i2 in out])
def mefisto_mesher(solids, max_edge_length):
verts = []
faces = []
for solid, max_edge in zip(*mlr([solids, max_edge_length])):
mesh = MeshPart.meshFromShape(Shape=solid, MaxLength=max_edge)
verts.append([v[:] for v in mesh.Topology[0]])
faces.append(mesh.Topology[1])
return verts, faces
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
params = [s.sv_get()[0] for s in self.inputs]
solids = []
for rad, height, origin, direc, angle in zip(*mlr(params)):
cylinder = Part.makeCylinder(rad, height, Base.Vector(origin), Base.Vector(direc), angle)
solids.append(cylinder)
self.outputs['Solid'].sv_set(solids)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
solids_in = self.inputs[0].sv_get()
matrixes = self.inputs[1].sv_get()
solids = []
for solid, matrix in zip(*mlr([solids_in, matrixes])):
solid_o = transform_solid(matrix, solid)
solids.append(solid_o)
self.outputs['Solid'].sv_set(solids)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
p = [s.sv_get()[0] for s in self.inputs]
solids = []
for l, w, h, o, d in zip(*mlr(p)):
box = Part.makeBox(l, w, h, Base.Vector(o), Base.Vector(d))
solids.append(box)
self.outputs['Solid'].sv_set(solids)
def draw_pols(verts, polygons, attributes, document):
svg = ''
scale = document.scale
height = document.height
func = draw_edge if len(polygons[0]) < 3 else draw_pol
for p, atts in zip(*mlr([polygons, attributes])):
svg += func(verts_pol(p, verts), scale, height)
if atts:
svg += atts.draw(document)
svg += '/>'
return svg
def process(self):
if not self.outputs[0].is_linked:
return
verts_in = self.inputs['Vertices'].sv_get(deepcopy=True)
commands_in = self.inputs['Commands'].sv_get(deepcopy=True)
shapes = []
atts_in = self.inputs['Fill / Stroke'].sv_get(deepcopy=False,
default=None)
for verts, commands, atts in zip(
*mlr([verts_in, commands_in, atts_in])):
shapes.append(SvgPath(verts, commands, atts, self))
self.outputs[0].sv_set(shapes)
def mefisto_mesher(self):
solids = self.inputs[0].sv_get()
max_edge_length = self.inputs['Max Edge Length'].sv_get()[0]
verts = []
faces = []
for solid, max_edge in zip(*mlr([solids, max_edge_length])):
mesh = MeshPart.meshFromShape(Shape=solid, MaxLength=max_edge)
verts.append([v[:] for v in mesh.Topology[0]])
faces.append(mesh.Topology[1])
return verts, faces
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
params = [s.sv_get()[0] for s in self.inputs]
solids = []
for rad, rad_small, origin, direc, angle in zip(*mlr(params)):
solid = Part.makeTorus(rad, rad_small, Base.Vector(origin),
Base.Vector(direc), 0, 360, angle)
solids.append(solid)
self.outputs['Solid'].sv_set(solids)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
solids_in = self.inputs[0].sv_get()
matrixes = self.inputs[1].sv_get()
solids = []
for solid, matrix in zip(*mlr([solids_in, matrixes])):
mat = Base.Matrix(*[i for v in matrix for i in v])
solid_o = solid.transformGeometry(mat)
solids.append(solid_o)
self.outputs['Solid'].sv_set(solids)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
p = [s.sv_get()[0] for s in self.inputs]
solids = []
for rad, ang1, ang2, ang3, origin, direc in zip(*mlr(p)):
sphere = Part.makeSphere(rad, Base.Vector(origin),
Base.Vector(direc), ang1, ang2, ang3)
solids.append(sphere)
self.outputs['Solid'].sv_set(solids)
def process(self):
if not any(socket.is_linked for socket in self.outputs):
return
objects_a = self.inputs[self["mode"]].sv_get()
objects_b = self.inputs[self["mode_b"] + 3].sv_get()
distances_out = []
closest_points_out_a = []
infos_out_a = []
closest_points_out_b = []
infos_out_b = []
for object_a, object_b, in zip(*mlr([objects_a, objects_b])):
distances = []
closest_points_a = []
infos_a = []
closest_points_b = []
infos_b = []
shape = get_shape(self.mode, object_a)
if self.mode_b == 'Vertex':
for v in object_b:
vertex = Part.Vertex(Base.Vector(v))
dist = shape.distToShape(vertex)
distances.append(dist[0])
closest_points_a.append(dist[1][0][0][:])
infos_a.append(dist[2][0][0:3])
else:
shape_b = get_shape(self.mode_b, object_b)
dist = shape.distToShape(shape_b)
distances.append(dist[0])
closest_points_a.append(dist[1][0][0][:])
infos_a.append(dist[2][0][0:3])
closest_points_b.append(dist[1][0][1][:])
infos_b.append(dist[2][0][3:])
closest_points_out_b.append(closest_points_b)
infos_out_b.append(infos_b)
distances_out.append(distances)
closest_points_out_a.append(closest_points_a)
infos_out_a.append(infos_a)
self.outputs['Distance'].sv_set(distances_out)
self.outputs['Closest Point A'].sv_set(closest_points_out_a)
self.outputs['Info A'].sv_set(infos_out_a)
self.outputs['Closest Point B'].sv_set(closest_points_out_b)
self.outputs['Info B'].sv_set(infos_out_b)
def process(self):
BML, Verts, Edges, Polys, vermask, edgmask, angllim = self.inputs
o1,o2,o3,o4,o5 = self.outputs
angle = angllim.sv_get()[0]
ret = []
bmlist = BML.sv_get([])
if Verts.is_linked:
bmlist.extend([bmesh_from_pydata(verts, edges, faces, normal_update=True) for verts, edges, faces in zip(*mlr([Verts.sv_get(), Edges.sv_get([[]]), Polys.sv_get([[]])]))])
if vermask.is_linked:
verm = [np.array(bm.verts[:])[ma] for bm,ma in zip(bmlist,vermask.sv_get())]
else:
verm = [bm.verts for bm in bmlist]
if edgmask.is_linked:
edgm = [np.array(bm.edges[:])[ma] for bm,ma in zip(bmlist,edgmask.sv_get())]
else:
edgm = [bm.edges for bm in bmlist]
udb, dlm = self.use_dissolve_boundaries, self.delimit
for bm, ang, vm, em in zip(bmlist, safc(bmlist, angle), verm, edgm):
# it's a little undocumented..
ret.append(dissolve_limit(bm, angle_limit=ang, use_dissolve_boundaries=udb, verts=vm, edges=em, delimit=dlm)['region'])
if o1.is_linked:
o1.sv_set([[v.co[:] for v in bm.verts]for bm in bmlist])
if o2.is_linked:
o2.sv_set([[[i.index for i in e.verts] for e in bm.edges]for bm in bmlist])
if o3.is_linked:
o3.sv_set([[[i.index for i in p.verts] for p in bm.faces]for bm in bmlist])
if o4.is_linked:
o4.sv_set(ret)
if o5.is_linked:
o5.sv_set(bmlist)
