792 lines
27 KiB
Python
792 lines
27 KiB
Python
from __future__ import annotations
|
|
import os
|
|
from math import floor
|
|
from typing import Any
|
|
import bpy
|
|
import numpy as np
|
|
from mathutils import Euler
|
|
from bpy.props import StringProperty, FloatProperty, IntProperty
|
|
|
|
from ...registry import register_class
|
|
from .. import slice
|
|
from ..slice import Pather, slice_at_range, SlicePaths
|
|
from ...infra.blender_mesh_capture import SlicingObject, capture_mesh_edges
|
|
from ...infra.blender_slice_nodes_generic import SliceNode, resolve_input
|
|
|
|
class SliceIntrinsics:
|
|
bed_x: float
|
|
bed_y: float
|
|
feedrate: float
|
|
extrusion_rate: float
|
|
|
|
def __init__(self, bed_x=250.0, bed_y=250.0, feedrate=1200.0, extrusion_rate=0.017):
|
|
self.bed_x = bed_x
|
|
self.bed_y = bed_y
|
|
self.feedrate = feedrate
|
|
self.extrusion_rate = extrusion_rate
|
|
|
|
# Basic Inputs
|
|
|
|
class InputNode(SliceNode):
|
|
input_type: str = ""
|
|
|
|
def __init_subclass__(cls, **kwargs):
|
|
super().__init_subclass__(**kwargs)
|
|
if "bl_label" not in cls.__dict__: cls.bl_label = cls.input_type
|
|
|
|
def init(self, context) -> None:
|
|
self.add_output(f"SLICESOCK_{self.bl_label}")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs):
|
|
return self.outputs.get(socket_name).value
|
|
|
|
@register_class
|
|
class SLICENODE_InputString(InputNode):
|
|
input_type = "String"
|
|
|
|
@register_class
|
|
class SLICENODE_InputFloat(InputNode):
|
|
input_type = "Float"
|
|
|
|
@register_class
|
|
class SLICENODE_InputInt(InputNode):
|
|
input_type = "Int"
|
|
|
|
@register_class
|
|
class SLICENODE_InputVectorRotation(InputNode):
|
|
input_type = "VectorRotation"
|
|
|
|
@register_class
|
|
class SLICENODE_InputObject(InputNode):
|
|
input_type = "Object"
|
|
bl_icon = "OBJECT_DATA"
|
|
|
|
@register_class
|
|
class SLICENODE_InputIntrinsics(SliceNode):
|
|
bl_label = "Printer Intrinsics"
|
|
|
|
bed_x: FloatProperty(name="Bed X", default=250.0) # pyright: ignore[reportInvalidTypeForm]
|
|
bed_y: FloatProperty(name="Bed Y", default=250.0) # pyright: ignore[reportInvalidTypeForm]
|
|
feedrate: FloatProperty(name="Feedrate", default=1200.0) # pyright: ignore[reportInvalidTypeForm]
|
|
extrusion_rate: FloatProperty(name="Extrusion Rate", default=0.017, precision=4) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def init(self, context):
|
|
self.add_output("SLICESOCK_Intrinsics")
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "bed_x")
|
|
layout.prop(self, "bed_y")
|
|
layout.prop(self, "feedrate")
|
|
layout.prop(self, "extrusion_rate")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SliceIntrinsics:
|
|
return SliceIntrinsics(
|
|
bed_x=self.bed_x,
|
|
bed_y=self.bed_y,
|
|
feedrate=self.feedrate,
|
|
extrusion_rate=self.extrusion_rate
|
|
)
|
|
|
|
# Math
|
|
|
|
@register_class
|
|
class SLICENODE_IntMath(SliceNode):
|
|
bl_label = "Integer Math"
|
|
|
|
operation: bpy.props.EnumProperty(
|
|
name="Operation",
|
|
items=[
|
|
('ADD', "Add", "Add the two values"),
|
|
('SUBTRACT', "Subtract", "Subtract the second value from the first"),
|
|
('MULTIPLY', "Multiply", "Multiply the two values"),
|
|
('DIVIDE', "Divide", "Integer division"),
|
|
('ABS', "Absolute", "Absolute value of the first value"),
|
|
('NEGATE', "Negate", "Negate the first value"),
|
|
('POWER', "Power", "First value raised to the power of the second"),
|
|
('MIN', "Minimum", "The smaller of the two values"),
|
|
('MAX', "Maximum", "The larger of the two values"),
|
|
('SIGN', "Sign", "The sign of the first value (-1, 0, or 1)"),
|
|
('DIVIDE_ROUND', "Divide Round", "Division rounded to the nearest integer"),
|
|
('DIVIDE_FLOOR', "Divide Floor", "Division rounded down"),
|
|
('DIVIDE_TRUNCATE', "Divide Truncate", "Division rounded towards zero"),
|
|
('MODULO_FLOORED', "Floored Modulo", "Modulo using floor division"),
|
|
('MODULO_TRUNCATED', "Truncated Modulo", "Modulo using truncated division"),
|
|
],
|
|
default='ADD'
|
|
) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def init(self, context):
|
|
self.add_output("SLICESOCK_IntRo", "Value")
|
|
|
|
self.add_input("SLICESOCK_Int", "Value")
|
|
self.add_input("SLICESOCK_Int", "Value")
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "operation", text="")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> int:
|
|
a: int = resolve_input(self.inputs[0])
|
|
b: int = resolve_input(self.inputs[1])
|
|
|
|
op = self.operation
|
|
try:
|
|
if op == 'ADD': return a + b
|
|
if op == 'SUBTRACT': return a - b
|
|
if op == 'MULTIPLY': return a * b
|
|
if op == 'DIVIDE': return a // b if b != 0 else 0
|
|
if op == 'ABS': return abs(a)
|
|
if op == 'NEGATE': return -a
|
|
if op == 'POWER': return int(a ** b) if not (a == 0 and b < 0) else 0
|
|
if op == 'MIN': return min(a, b)
|
|
if op == 'MAX': return max(a, b)
|
|
if op == 'SIGN': return (a > 0) - (a < 0)
|
|
if op == 'DIVIDE_ROUND': return int(round(a / b)) if b != 0 else 0
|
|
if op == 'DIVIDE_FLOOR': return a // b if b != 0 else 0
|
|
if op == 'DIVIDE_TRUNCATE': return int(a / b) if b != 0 else 0
|
|
if op == 'MODULO_FLOORED': return a % b if b != 0 else 0
|
|
if op == 'MODULO_TRUNCATED': return a - (b * int(a / b)) if b != 0 else 0
|
|
except Exception:
|
|
return 0
|
|
return 0
|
|
|
|
@register_class
|
|
class SLICENODE_GetMesh(SliceNode):
|
|
bl_label = "Get Mesh"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Object")
|
|
self.add_output("SLICESOCK_Mesh")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicingObject | None:
|
|
if socket_name != "Mesh": return None
|
|
|
|
obj: Any = resolve_input(self.inputs.get("Object"))
|
|
|
|
so = SlicingObject(obj, obj.name)
|
|
|
|
return so
|
|
|
|
@register_class
|
|
class SLICENODE_GetPaths(SliceNode):
|
|
bl_label = "Get Paths"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Object")
|
|
self.add_output("SLICESOCK_Paths")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
obj: Any = resolve_input(self.inputs.get("Object"))
|
|
|
|
so: list[np.ndarray] = capture_mesh_edges(obj)
|
|
|
|
return SlicePaths(so)
|
|
|
|
@register_class
|
|
class SLICENODE_SliceShells(SliceNode):
|
|
bl_label = "Slice Shells"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Mesh")
|
|
self.add_input("SLICESOCK_Float", "Layer Height").value = 0.2
|
|
self.add_output("SLICESOCK_Paths")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
if socket_name != "Paths": return SlicePaths()
|
|
|
|
slicingmesh: SlicingObject | None = resolve_input(self.inputs.get("Mesh"))
|
|
layer_height: float = resolve_input(self.inputs.get("Layer Height"))
|
|
|
|
if not slicingmesh: return SlicePaths()
|
|
|
|
min = slicingmesh.mesh[:,0:3,2:3].min()
|
|
min = floor(min / layer_height) * layer_height
|
|
max = slicingmesh.mesh[:,0:3,2:3].max()
|
|
|
|
z_values = np.arange(min, max + layer_height, layer_height)
|
|
|
|
slices_group: list[list[np.ndarray]] | None = slice_at_range([slicingmesh.mesh], z_values)
|
|
assert slices_group
|
|
slices = slices_group[0]
|
|
|
|
return SlicePaths(slices)
|
|
|
|
@register_class
|
|
class SLICENODE_BufferShells(SliceNode):
|
|
bl_label = "Buffer Shells"
|
|
|
|
shape_option: bpy.props.EnumProperty(
|
|
name="Miter",
|
|
items=[
|
|
('round', "Round", ""),
|
|
('square', "Square", ""),
|
|
('flat', "Flat", "")
|
|
]
|
|
) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Paths")
|
|
self.add_input("SLICESOCK_Float", "Distance").value = 0
|
|
self.add_input("SLICESOCK_VectorRotation", "Rotation")
|
|
self.add_output("SLICESOCK_Paths")
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "shape_option")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
if socket_name != "Paths": return SlicePaths()
|
|
|
|
paths: SlicePaths = resolve_input(self.inputs.get("Paths"))
|
|
distance: float = resolve_input(self.inputs.get("Distance")) or 0.0
|
|
rotation: Any = resolve_input(self.inputs.get("Rotation")) or (0.0, 0.0, 0.0)
|
|
|
|
if not paths: return SlicePaths()
|
|
|
|
if any(rotation):
|
|
# De-rotate shells to Z-perpendicular plane
|
|
mat = Euler(rotation).to_matrix().inverted()
|
|
mat_np = np.array(mat)
|
|
prepared_paths = [s @ mat_np.T for s in paths]
|
|
else:
|
|
prepared_paths = paths
|
|
|
|
# Buffer
|
|
res_paths, res_groups = slice.buffer_slice(prepared_paths, distance, miter=self.shape_option)
|
|
|
|
if any(rotation):
|
|
# Re-rotate shells back
|
|
mat_inv = Euler(rotation).to_matrix()
|
|
mat_inv_np = np.array(mat_inv)
|
|
final_paths = [s @ mat_inv_np.T for s in res_paths]
|
|
else:
|
|
final_paths = res_paths
|
|
|
|
return SlicePaths(final_paths, res_groups)
|
|
|
|
@register_class
|
|
class SLICENODE_BufferShellsMultiple(SliceNode):
|
|
bl_label = "Buffer Shells Multiple"
|
|
|
|
shape_option: bpy.props.EnumProperty(
|
|
name="Miter",
|
|
items=[
|
|
('round', "Round", ""),
|
|
('square', "Square", ""),
|
|
('flat', "Flat", "")
|
|
]
|
|
) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Paths")
|
|
self.add_input("SLICESOCK_Float", "Distance").value = 0
|
|
self.add_input("SLICESOCK_Float", "Width Step").value = 0.4
|
|
self.add_input("SLICESOCK_Int", "Count").value = 2
|
|
self.add_input("SLICESOCK_VectorRotation", "Rotation")
|
|
self.add_output("SLICESOCK_Paths")
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "shape_option")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
if socket_name != "Paths": return SlicePaths()
|
|
|
|
paths: SlicePaths = resolve_input(self.inputs.get("Paths"))
|
|
base_distance: float = resolve_input(self.inputs.get("Distance")) or 0.0
|
|
width_step: float = resolve_input(self.inputs.get("Width Step")) or 0.0
|
|
count: int = resolve_input(self.inputs.get("Count")) or 1
|
|
rotation: Any = resolve_input(self.inputs.get("Rotation")) or (0.0, 0.0, 0.0)
|
|
|
|
if not paths: return SlicePaths()
|
|
|
|
if any(rotation):
|
|
mat = Euler(rotation).to_matrix().inverted()
|
|
mat_np = np.array(mat)
|
|
prepared_paths = [s @ mat_np.T for s in paths]
|
|
else:
|
|
prepared_paths = paths
|
|
|
|
all_res_paths = []
|
|
all_res_groups = []
|
|
|
|
for i in range(count):
|
|
dist = base_distance + (i * width_step)
|
|
res_paths, res_groups = slice.buffer_slice(prepared_paths, dist, miter=self.shape_option)
|
|
all_res_paths.extend(res_paths)
|
|
all_res_groups.extend(res_groups)
|
|
|
|
if any(rotation):
|
|
mat_inv = Euler(rotation).to_matrix()
|
|
mat_inv_np = np.array(mat_inv)
|
|
final_paths = [s @ mat_inv_np.T for s in all_res_paths]
|
|
else:
|
|
final_paths = all_res_paths
|
|
|
|
return SlicePaths(final_paths, all_res_groups)
|
|
|
|
@register_class
|
|
class SLICENODE_Infill(SliceNode):
|
|
bl_label = "Infill"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Paths")
|
|
self.add_input("SLICESOCK_Float", "Density").value = 2.0
|
|
self.add_input("SLICESOCK_Float", "Infill Rotation").value = 0.0
|
|
self.add_input("SLICESOCK_VectorRotation", "Layer Rotation")
|
|
self.add_output("SLICESOCK_Paths")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
if socket_name != "Paths": return SlicePaths()
|
|
|
|
paths: SlicePaths = resolve_input(self.inputs.get("Paths"))
|
|
density: float = resolve_input(self.inputs.get("Density")) or 2.0
|
|
infill_rotation: float = resolve_input(self.inputs.get("Infill Rotation")) or 0.0
|
|
rotation: Any = resolve_input(self.inputs.get("Layer Rotation")) or (0.0, 0.0, 0.0)
|
|
|
|
if not paths: return SlicePaths()
|
|
|
|
p: SlicePaths
|
|
if any(rotation):
|
|
# De-rotate shells to Z-perpendicular plane
|
|
mat = Euler(rotation).to_matrix().inverted()
|
|
mat_np = np.array(mat)
|
|
p = SlicePaths([s @ mat_np.T for s in paths], paths.groups)
|
|
else:
|
|
p = paths
|
|
|
|
res_paths, res_groups = slice.infill_slice(p, density, rotation_deg=infill_rotation)
|
|
|
|
if any(rotation):
|
|
# Re-rotate shells back
|
|
mat_inv = Euler(rotation).to_matrix()
|
|
mat_inv_np = np.array(mat_inv)
|
|
p = SlicePaths([s @ mat_inv_np.T for s in res_paths], res_groups)
|
|
else:
|
|
p = SlicePaths(res_paths, res_groups)
|
|
|
|
return p
|
|
|
|
@register_class
|
|
class SLICENODE_PathsToGcode(SliceNode):
|
|
bl_label = "Paths to Gcode"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Paths")
|
|
self.add_input("SLICESOCK_Intrinsics")
|
|
self.add_output("SLICESOCK_Gcode")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> str:
|
|
paths: list[np.ndarray] = resolve_input(self.inputs.get("Paths"))
|
|
intrinsics: SliceIntrinsics | None = resolve_input(self.inputs.get("Intrinsics"))
|
|
|
|
pather: Pather = Pather(paths)
|
|
if intrinsics:
|
|
# Note: Pather currently uses bed_center_x/y as its internal attributes.
|
|
# We map the bed size center to these attributes if provided.
|
|
pather.bed_center_x = intrinsics.bed_x / 2.0
|
|
pather.bed_center_y = intrinsics.bed_y / 2.0
|
|
pather.feedrate = intrinsics.feedrate
|
|
pather.extrusion_rate = intrinsics.extrusion_rate
|
|
|
|
gcode: str = pather.to_gcode()
|
|
return gcode
|
|
|
|
@register_class
|
|
class SLICENODE_GcodeBlock(SliceNode):
|
|
bl_label = "Gcode Block"
|
|
|
|
gcode: StringProperty(name="Gcode", default="") # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def init(self, context):
|
|
self.add_output("SLICESOCK_Gcode")
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "gcode", text="")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> str:
|
|
return self.gcode
|
|
|
|
@register_class
|
|
class SLICENODE_GcodeHelper(SliceNode):
|
|
bl_label = "Gcode Helper"
|
|
|
|
command: bpy.props.EnumProperty(
|
|
name="Command",
|
|
items=[
|
|
('G0', "G0: Rapid Move", "Fast movement without extrusion"),
|
|
('G1', "G1: Linear Move", "Movement with extrusion"),
|
|
('G4', "G4: Dwell", "Wait for time (e.g. P500 for 500ms or S5 for 5s)"),
|
|
('G28', "G28: Home All", "Home all axes"),
|
|
('G90', "G90: Absolute Pos", "Set to absolute positioning"),
|
|
('G91', "G91: Relative Pos", "Set to relative positioning"),
|
|
('G92', "G92: Set Position", "Set the current position to specific values (e.g. G92 E0)"),
|
|
('M0', "M0: Stop/Wait", "Stop and wait for user button press"),
|
|
('M25', "M25: Pause SD", "Pause SD print (Marlin/RepRap)"),
|
|
('M104', "M104: Set Temp", "Set hotend temperature"),
|
|
('M109', "M109: Wait Temp", "Set hotend temperature and wait"),
|
|
('M140', "M140: Set Bed Temp", "Set bed temperature"),
|
|
('M190', "M190: Wait Bed Temp", "Set bed temperature and wait"),
|
|
('M106', "M106: Fan On", "Turn on cooling fan"),
|
|
('M107', "M107: Fan Off", "Turn off cooling fan"),
|
|
('M117', "M117: Message", "Display message on printer LCD"),
|
|
('M220', "M220: Speed Factor", "Set speed percentage (e.g. S110 for 110%)"),
|
|
('M221', "M221: Flow Factor", "Set flow percentage (e.g. S95 for 95%)"),
|
|
('M300', "M300: Beep", "Play beep sound"),
|
|
('M400', "M400: Wait Finish", "Wait for all current moves to finish"),
|
|
('M600', "M600: Color Change", "Filament change / Color change"),
|
|
('M82', "M82: Abs Extrusion", "Set extrusion to absolute mode"),
|
|
('M83', "M83: Rel Extrusion", "Set extrusion to relative mode"),
|
|
('PAUSE', "PAUSE: Klipper Pause", "Pause print (Klipper macro)"),
|
|
('T', "T: Change Extruder", "Switch to a different extruder (e.g. T0, T1)"),
|
|
],
|
|
default='G1'
|
|
) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
parameters: StringProperty(name="Params", default="") # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def init(self, context):
|
|
self.add_output("SLICESOCK_Gcode")
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "command", text="")
|
|
# Commands that don't need parameters
|
|
no_params = {'G28', 'G90', 'G91', 'M0', 'M25', 'M107', 'M400', 'M600', 'M82', 'M83', 'PAUSE'}
|
|
if self.command not in no_params:
|
|
layout.prop(self, "parameters", text="Parameters")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> str:
|
|
cmd = self.command
|
|
params = self.parameters.strip()
|
|
if params:
|
|
# T commands usually don't have a space (e.g. T0)
|
|
if cmd == 'T':
|
|
return f"{cmd}{params}"
|
|
return f"{cmd} {params}"
|
|
return cmd
|
|
|
|
### Joiners
|
|
|
|
class SliceNodeJoiner(SliceNode):
|
|
socket_type: str = ""
|
|
output_socket_type: str = ""
|
|
|
|
def init(self, context):
|
|
self.add_output(self.output_socket_type or self.socket_type)
|
|
|
|
def update(self) -> None:
|
|
def is_active(input) -> bool:
|
|
return input.is_linked or getattr(input, 'value', False)
|
|
|
|
if len(self.inputs) == 0:
|
|
self.add_input(self.socket_type)
|
|
return
|
|
|
|
if is_active(self.inputs[-1]):
|
|
self.add_input(self.socket_type)
|
|
|
|
while True:
|
|
if len(self.inputs) < 2: break
|
|
if not is_active(self.inputs[-1]) and not is_active(self.inputs[-2]):
|
|
self.inputs.remove(self.inputs[-2])
|
|
continue
|
|
break
|
|
|
|
@register_class
|
|
class SLICENODE_JoinGcode(SliceNodeJoiner):
|
|
bl_label = "Join Gcode"
|
|
socket_type = "SLICESOCK_Gcode"
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> str:
|
|
gcode_input: list[str] = []
|
|
for input in self.inputs:
|
|
gcode_input += [resolve_input(input)] or [""]
|
|
return "\n".join(gcode_input)
|
|
|
|
|
|
@register_class
|
|
class SLICENODE_JoinSlices(SliceNodeJoiner):
|
|
bl_label = "Join Slices"
|
|
socket_type = "SLICESOCK_Paths"
|
|
|
|
operation: bpy.props.EnumProperty(
|
|
name="Operation",
|
|
items=[
|
|
('UNION', "Union", "Union of the slices"),
|
|
('INTERSECTION', "Intersection", "Intersection of the slices"),
|
|
('DIFFERENCE', "Subtract", "Clipping of the first slice"),
|
|
('XOR', "Exclusive or", "Exclusive or of the slices"),
|
|
],
|
|
default='UNION'
|
|
) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "operation", text="")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
accumulated: SlicePaths = SlicePaths()
|
|
current: SlicePaths = SlicePaths()
|
|
for input in self.inputs:
|
|
current = resolve_input(input)
|
|
|
|
if not current:
|
|
continue
|
|
|
|
if not accumulated:
|
|
accumulated = current
|
|
current = SlicePaths()
|
|
continue
|
|
|
|
# Boolean operation loses specific per-segment grouping as it merges polygons.
|
|
# We return a new SlicePaths from the result.
|
|
res = slice.boolean_slice(accumulated, current, self.operation)
|
|
accumulated = SlicePaths(res)
|
|
current = SlicePaths()
|
|
|
|
return accumulated
|
|
|
|
@register_class
|
|
class SLICENODE_JoinMesh(SliceNodeJoiner):
|
|
bl_label = "Join Mesh"
|
|
socket_type = "SLICESOCK_Mesh"
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicingObject:
|
|
merged_mesh = SlicingObject()
|
|
|
|
for input in self.inputs:
|
|
mesh =resolve_input(input)
|
|
if mesh:
|
|
merged_mesh.mesh = np.concatenate([merged_mesh.mesh, mesh.mesh], axis=0)
|
|
|
|
return merged_mesh
|
|
|
|
@register_class
|
|
class SLICENODE_JoinPaths(SliceNodeJoiner):
|
|
bl_label = "Join Paths"
|
|
socket_type = "SLICESOCK_Paths"
|
|
|
|
mode: bpy.props.EnumProperty(
|
|
name="Mode",
|
|
items=[
|
|
('EXTEND', "Extend", "Append paths sequentially"),
|
|
('ZIP', "Zip", "Interleave paths from all inputs"),
|
|
],
|
|
default='EXTEND'
|
|
) # pyright: ignore[reportInvalidTypeForm]
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.prop(self, "mode", text="")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> SlicePaths:
|
|
inputs_data: list[SlicePaths] = []
|
|
for input in self.inputs:
|
|
paths = resolve_input(input)
|
|
if paths:
|
|
inputs_data.append(paths)
|
|
|
|
if not inputs_data:
|
|
return SlicePaths()
|
|
|
|
if self.mode == 'EXTEND':
|
|
merged = SlicePaths()
|
|
for paths in inputs_data:
|
|
merged.extend_with_groups(paths)
|
|
return merged
|
|
|
|
elif self.mode == 'ZIP':
|
|
# Group-based Zip: sequentially add each group from all inputs.
|
|
# E.g. Group 1 (In1), Group 1 (In2), Group 2 (In1), Group 2 (In2)...
|
|
all_groups = set()
|
|
grouped_inputs = []
|
|
for p_list in inputs_data:
|
|
d = {}
|
|
for i, g in enumerate(p_list.groups):
|
|
all_groups.add(g)
|
|
d.setdefault(g, []).append(p_list[i])
|
|
grouped_inputs.append(d)
|
|
|
|
sorted_groups = sorted(list(all_groups))
|
|
|
|
merged = SlicePaths()
|
|
for g in sorted_groups:
|
|
for d in grouped_inputs:
|
|
group_paths = d.get(g, [])
|
|
for p in group_paths:
|
|
merged.append_with_group(p, g)
|
|
return merged
|
|
|
|
return SlicePaths()
|
|
|
|
### I/O
|
|
|
|
@register_class
|
|
class SLICENODE_LoadGcode(SliceNode):
|
|
bl_label = "Load Gcode File"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_FilePath", "Filepath")
|
|
self.add_output("SLICESOCK_Gcode")
|
|
|
|
def evaluate_output(self, socket_name: str, **_kwargs) -> str:
|
|
path = resolve_input(self.inputs.get("Filepath"))
|
|
if not path: return ""
|
|
abs_path = bpy.path.abspath(path)
|
|
if os.path.exists(abs_path):
|
|
with open(abs_path, 'r', encoding='utf-8') as f:
|
|
return f.read()
|
|
return ""
|
|
|
|
class ExecSliceNode(SliceNode):
|
|
button_label: str = 'Execute'
|
|
|
|
def draw_buttons(self, context, layout):
|
|
assert layout
|
|
layout.operator("slicenode.execute", text=self.button_label).node_name = self.name
|
|
|
|
@register_class
|
|
class SLICENODE_GcodeToFile(ExecSliceNode):
|
|
bl_label = "Gcode To File"
|
|
|
|
button_label = "Generate File"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Gcode")
|
|
self.add_input("SLICESOCK_FilePath", "Filename")
|
|
|
|
def evaluate(self):
|
|
gcode: str = resolve_input(self.inputs.get("Gcode"))
|
|
filename: str = resolve_input(self.inputs.get("Filename"))
|
|
|
|
filepath = bpy.path.abspath(filename)
|
|
os.makedirs(os.path.dirname(filepath) or ".", exist_ok=True)
|
|
|
|
with open(filepath, "w", encoding="utf-8", newline="\n") as f:
|
|
f.write(gcode)
|
|
|
|
return 'ok'
|
|
|
|
@register_class
|
|
class SLICENODE_GcodeToMesh(ExecSliceNode):
|
|
bl_label = "Gcode to Mesh"
|
|
|
|
button_label = "Update Debug Mesh"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Gcode")
|
|
|
|
def evaluate(self):
|
|
gcode: str = resolve_input(self.inputs.get("Gcode"))
|
|
if not gcode:
|
|
return 'empty'
|
|
|
|
segments = []
|
|
last_x, last_y, last_z = 0.0, 0.0, 0.0
|
|
last_e = 0.0
|
|
|
|
offset_x, offset_y = 0.0, 0.0
|
|
|
|
for line in gcode.splitlines():
|
|
# Parse metadata from comments
|
|
if ';' in line:
|
|
comment = line.split(';', 1)[1].strip()
|
|
if comment.startswith("OFFSET_X="):
|
|
try: offset_x = float(comment.split('=')[1])
|
|
except ValueError: pass
|
|
elif comment.startswith("OFFSET_Y="):
|
|
try: offset_y = float(comment.split('=')[1])
|
|
except ValueError: pass
|
|
|
|
line_no_comment = line.split(';')[0].strip()
|
|
if not line_no_comment: continue
|
|
|
|
parts = line_no_comment.split()
|
|
cmd = parts[0].upper()
|
|
|
|
params = {}
|
|
for p in parts[1:]:
|
|
if len(p) < 2: continue
|
|
try:
|
|
# Scale coordinates by 0.001 (mm to Blender units)
|
|
val = float(p[1:])
|
|
if p[0].upper() in 'XYZ':
|
|
val *= 0.001
|
|
params[p[0].upper()] = val
|
|
except ValueError: continue
|
|
|
|
new_x = params.get('X', last_x)
|
|
new_y = params.get('Y', last_y)
|
|
new_z = params.get('Z', last_z)
|
|
new_e = params.get('E', last_e)
|
|
|
|
if cmd == 'G1':
|
|
is_extruding = new_e > 0
|
|
|
|
if is_extruding:
|
|
# Subtract offsets (scaled to Blender units) to return to original space
|
|
ox, oy = offset_x * 0.001, offset_y * 0.001
|
|
segments.append((
|
|
(last_x - ox, last_y - oy, last_z),
|
|
(new_x - ox, new_y - oy, new_z)
|
|
))
|
|
|
|
last_x, last_y, last_z = new_x, new_y, new_z
|
|
last_e = new_e
|
|
|
|
if not segments:
|
|
return 'no segments'
|
|
|
|
# Create or find "Debug" mesh object
|
|
mesh_name = "Debug"
|
|
if mesh_name in bpy.data.objects:
|
|
obj = bpy.data.objects[mesh_name]
|
|
mesh = obj.data
|
|
mesh.clear_geometry()
|
|
else:
|
|
mesh = bpy.data.meshes.new(mesh_name)
|
|
obj = bpy.data.objects.new(mesh_name, mesh)
|
|
assert bpy.context.collection
|
|
bpy.context.collection.objects.link(obj)
|
|
|
|
vertices = []
|
|
edges = []
|
|
for i, (p1, p2) in enumerate(segments):
|
|
vertices.extend([p1, p2])
|
|
edges.append((2*i, 2*i + 1))
|
|
|
|
mesh.from_pydata(vertices, edges, [])
|
|
mesh.update()
|
|
|
|
# Assign Geometry Nodes nodegroup for preview
|
|
ng_name = "Nonplanar Slicing Preview"
|
|
if ng_name in bpy.data.node_groups:
|
|
ng = bpy.data.node_groups[ng_name]
|
|
# Check if already assigned
|
|
has_preview = False
|
|
for mod in obj.modifiers:
|
|
if mod.type == 'NODES' and mod.node_group == ng: # type: ignore
|
|
has_preview = True
|
|
break
|
|
|
|
if not has_preview:
|
|
mod = obj.modifiers.new(name="Preview", type='NODES') # type: ignore
|
|
mod.node_group = ng
|
|
|
|
return 'ok'
|
|
|
|
@register_class
|
|
class SLICENODE_Test(ExecSliceNode):
|
|
bl_label = "Test"
|
|
|
|
button_label = "Test"
|
|
|
|
def init(self, context):
|
|
self.add_input("SLICESOCK_Gcode")
|
|
|
|
def evaluate(self):
|
|
_ = resolve_input(self.inputs.get("Gcode"))
|
|
return 'ok'
|